Um9uYWxkaW5obyBvbnRrZW50IGJhbmRlbiBtZXQgdmVybWVlbmQgY3J5cHRvLXBpcmFtaWRlc3BlbA==

2023-09-13, 10:29

<p><img src="https://gimg2.gateimg.com/image/article/1694600463RDZZ 1.jpeg" alt=""></p>
<h2 id="h2-Te20lang20niet20gelezen145426"><a name="Te lang; niet gelezen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Te lang; niet gelezen</h2><p>Ronaldinho heeft de beweringen weerlegd dat hij betrokken was bij een frauduleus crypto-schema genaamd 18kRonaldinho.</p>
<p>De Braziliaanse autoriteiten kunnen Ronaldo de Assis Moreira vasthouden omdat hij niet aanwezig was bij de andere zittingen van de rechtbank.</p>
<p>Kylian Mbappe, Cristiano Ronaldo, Luis Suarez, Lionel Messi, Roberto Carlos en Antoine Griezmann zijn voorbeelden van voetbalsterren die betrokken zijn bij cryptocurrencies.</p>
<h2 id="h2-Introductie197851"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Veel sportpersoonlijkheden, waaronder atleten en voetballers, zijn betrokken bij cryptocurrencies en andere digitale activa. Bijvoorbeeld, bekende voetballers zoals Kylian Mbappe, <a href="https://www.gate.io/nft/42574" target="_blank">Cristiano Ronaldo</a>, Luis Suarez, Lionel Messi, Roberto Carlos en Antoine Griezmann nemen deel aan crypto-activiteiten.</p>
<p>Vandaag bespreken we hoe sommige van deze voetbalsterren deelnemen aan crypto-activiteiten. We zullen ook kijken naar beschuldigingen tegen Ronaldinho’s betrokkenheid bij <a href="https://www.gate.io/bitwiki/detail/205/pyramid-scheme" target="_blank">een crypto-piramidespel</a>.</p>
<p>Neem een kijkje bij <a href="https://www.gate.io/nft/collection/10886/Fantasy-Football" target="_blank">Fantasy Football NFTs</a></p>
<h2 id="h2-Ronaldinho20ontkent20betrokkenheid20bij20een20cryptopiramidespel743335"><a name="Ronaldinho ontkent betrokkenheid bij een crypto-piramidespel" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ronaldinho ontkent betrokkenheid bij een crypto-piramidespel</h2><p>De populaire voetbalster Ronaldo de Assis Moreira, voornamelijk bekend als Ronaldinho Gaucho, heeft ontkend dat hij betrokken was bij een crypto-piramidespel dat investeerders voor meer dan $61 miljoen heeft opgelicht. Op 31 augustus presenteerde de gepensioneerde voetballer Ronaldinho Gaúcho zijn kant van het verhaal tijdens een hoorzitting in het congres in Brazilië.</p>
<p>Ronaldinho ontkende elke betrokkenheid bij het schema genaamd ‘18kRonaldinho’ dat investeerders een dagelijkse opbrengst van 2% beloofde op hun geïnvesteerde crypto-activa.</p>
<p>De Braziliaanse autoriteiten zeiden: “Het bedrijf beweerde te werken met cryptocurrency-handel en arbitrage en beloofde zijn klanten een inkomen tot 2% per dag, vermoedelijk gebaseerd op transacties met digitale valuta’s, wat verdenkingen wekte dat het een financiële piramide was vanwege beloften van hoge en snelle betalingen.”</p>
<p>De rechtszaak tegen hem eist $61 miljoen aan schadevergoeding. Desalniettemin zei Ronaldinho ter verdediging dat hij ook slachtoffer was van de zwendel, aangezien zijn beelden en naam zonder zijn toestemming werden gebruikt.</p>
<p>Tijdens de hoorzitting toonde het panel Ronaldinho zijn foto’s die werden gebruikt als onderdeel van het marketingmateriaal van het piramidespel. Desalniettemin beweerde Ronaldinho dat de foto’s in 2019 waren gemaakt toen hij samenwerkte met een van de dochterondernemingen van het bedrijf, een Amerikaans horlogebedrijf genaamd 18k Watch Corporation, dat horloges verkoopt.</p>
<p>Hij zei: ‘Ze hebben mijn naam misbruikt om de bedrijfsnaam van dit bedrijf te creëren.’ Volgens een bron weigerde hij echter om enkele vragen van het panel te beantwoorden. Bijvoorbeeld, toen Aureo Ribeiro, de voorzitter van het onderzoek, hem vroeg of hij bereid was om de slachtoffers van de cryptofraude te vergoeden, bleef hij stil.</p>
<p>Volgens Ronaldinho heeft de 18k Watch Corporation een reeks horloges gelanceerd met afbeeldingen van bepaalde populaire voetballers, waaronder hijzelf. Hij benadrukte echter dat het bedrijf zijn contract heeft beëindigd voordat het geïmplementeerd werd.</p>
<p>Lees ook: <a href="https://www.gate.io/price/view/sports" target="_blank">Top sport Crypto Coins &amp; Tokens op basis van marktkapitalisatie</a></p>
<h2 id="h2-Rechtszaak20eist206120miljoen20van20Ronaldinho712761"><a name="Rechtszaak eist $61 miljoen van Ronaldinho" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Rechtszaak eist $61 miljoen van Ronaldinho</h2><p>Zoals hierboven aangegeven, eist de rechtszaak tegen Ronaldinho een totaal van 300 miljoen reais, wat overeenkomt met ongeveer $60,66 miljoen als compensatie. Volgens Reuters heeft het Consumer Relations Institute of Brazil de groepsvordering in 2020 ingediend.</p>
<h2 id="h2-Ronaldinho20maakt20zich20zorgen20over20politieoptreden20na20het20missen20van20rechtszaken126505"><a name="Ronaldinho maakt zich zorgen over politieoptreden na het missen van rechtszaken" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ronaldinho maakt zich zorgen over politieoptreden na het missen van rechtszaken</h2><p>Op dit moment is Ronaldinho bang voor politie represailles nadat hij niet aanwezig was bij twee rechtbankzittingen in augustus. Zo heeft hij de laatste hoorzitting op 24 augustus gemist met als reden slechte weersomstandigheden. Hij beweerde dat het slechte weer leidde tot annuleringen van de vluchten die hij wilde nemen.</p>
<p>Als gevolg van zijn nalatigheid om de genoemde gerechtelijke procedures bij te wonen, kunnen de Braziliaanse autoriteiten hem vasthouden onder voorwaarden en voor een nog onbekende periode. Als de autoriteiten toegeeflijk zijn, kunnen ze hem een boete opleggen omdat hij niet aanwezig was bij de rechtbankzittingen.</p>
<p>Kortom, het Congres onderzoekt momenteel in totaal 11 crypto-gerelateerde frauduleuze zaken waarbij de daders enorme rendementen beloofden aan de slachtoffers.</p>
<h2 id="h2-1020Topspelers20Actief20in20Cryptocurrency53416"><a name="10 Topspelers Actief in Cryptocurrency" class="reference-link"></a><span class="header-link octicon octicon-link"></span>10 Topspelers Actief in Cryptocurrency</h2><p>Afgezien van Ronaldo de Assis Moreira zijn er verschillende vroegere en huidige voetballers in crypto. Kylian Mbappé, Cristiano Ronaldo, Luis Suarez, Lionel Messi, Roberto Carlos en Antoine Griezmann zijn voorbeelden van andere voetballers die betrokken zijn bij cryptocurrencies.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/529/celebrities-that-have-entered-the-nft-world-like-owning-bayc" target="_blank">Beroemdheden die de NFT-wereld zijn binnengekomen</a></p>
<h2 id="h2-Lionel20Messi631343"><a name="Lionel Messi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Lionel Messi</h2><p>Lionel Messi, een van de grootste voetballers aller tijden, is een voorbeeld van een individu die geïnteresseerd is in crypto en voetbal. Bij de overgang van Barcelona naar Paris St. Germain was de deal inclusief een gedeeltelijke betaling in cryptocurrency.</p>
<p>Verder heeft Messi in 2022 een overeenkomst gesloten met Socios.com, een digitaal fan-tokenbedrijf, om het merk te promoten. De deal ter waarde van meer dan $20 miljoen stelde Messi in staat deel te nemen aan de promotiecampagne van Socios ter voorbereiding op het Wereldkampioenschap in Qatar. Desalniettemin werd Messi al in 2018 benoemd tot ambassadeur van Sirin Labs, een fabrikant van op blockchain gebaseerde smartphones.</p>
<h2 id="h2-Kylian20Mbappe956444"><a name="Kylian Mbappe" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kylian Mbappe</h2><p>Kylian Mbappe, een sensationele voetballer, is een ander voorbeeld van iemand die actief is in zowel crypto als sport. Mbappe maakte voor het eerst kennis met cryptocurrency toen hij op 10 maart zijn debuutgoal scoorde voor Paris Saint-Germain (PSG).</p>
<p>Na dat doelpunt doneerde Kinetic Capital en Gravitas Limited, een crypto bedrijf, zijn inheemse <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Op basis van de token, Kineticcoachcoin (KKC), aan Mbappe. Vanaf daar begon hij cryptocurrencies te gebruiken.</p>
<h2 id="h2-Neymar20Jr587342"><a name="Neymar Jr." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Neymar Jr.</h2><p>Een van de sterren in crypto is Neymar Jr., de Braziliaanse voetballer <a href="/price/icon-icx" rel="nofollow noopener noreferrer" target="_blank">ICON</a>, die tot nu toe heeft samengewerkt met een aantal digitale projecten die gebruik maken van ‘spelers die crypto-campagnes promoten’. Als gevolg hiervan heeft hij crypto-projecten gepromoot via video’s en berichten op sociale media.</p>
<p>Hij investeert ook in cryptovaluta. Als voorbeeld is hij bekend om zijn investering in Bitstamp, een bekend handelsplatform. Daarnaast steekt hij ook geld in andere digitale activa, vooral niet-vervangbare tokens. Zo heeft hij bijvoorbeeld in 2022 meer dan $1 miljoen uitgegeven aan 2 NFT’s die deel uitmaken van de <a href="div class=" rel="nofollow noopener noreferrer" target="_blank" title="blog-details-info\&quot;> <div>Author:** Mashell C.**, Gate.io Researcher <div class=\&quot;info-tips\&quot;>\*This article represents only the views of the researcher and does not constitute any investment suggestions. <div>\*Gate.io reserves all rights to this article. Reposting of the article will be permitted provided Gate.io is referenced. In all cases, legal action will be taken due to copyright infringement. </div> \&quot;Bored Ape Yacht Club">Bored Ape Yacht Club</a> (BAYC) project.</p>
<h2 id="h2-Cristiano20Ronaldo658198"><a name="Cristiano Ronaldo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cristiano Ronaldo</h2><p>De volgende voetbalster die actief is in cryptocurrency is Christiano Ronaldo. Interessant genoeg verdient de Portugese aanvaller ongeveer $35 miljoen via lucratieve sport sponsorschap deals.</p>
<p>Bijvoorbeeld heeft Stryking, een opkomend crypto-bedrijf, Ronaldo aangesteld als een van zijn woordvoerders. Stryking wil dat Ronaldo veel sportfans lokt om zijn producten te gebruiken. In feite biedt het platform zijn klanten de mogelijkheid om speciale virtuele goederen te kopen, waaronder wedstrijdkaartjes en gesigneerde shirts.</p>
<p>Bovendien heeft Ronaldo onlangs veel geld geïnvesteerd in MC10, een veelbelovend cryptobedrijf. Daarnaast gebruikt hij zijn sociale mediaplatforms om de producten van MC10 te promoten. En als tegenprestatie verdient hij aandelen in MC10, waardoor zijn betrokkenheid bij de cryptobranche toeneemt.</p>
<h2 id="h2-Luis20Suarez660645"><a name="Luis Suarez" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Luis Suarez</h2><p>Luis Suarez, een van de best beoordeelde voetbalsterren in crypto, werkt al lange tijd samen met verschillende cryptocurrency-start-ups, waaronder Stox, een op <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> gebaseerd voorspellingsmarktprotocol.</p>
<p>Bijvoorbeeld betrekt hij zijn meer dan 30 miljoen Instagram-volgers bij cryptogerelateerde activiteiten, zoals het doen van voorspellingen op Stox. Als gevolg daarvan zijn een aantal van zijn sociale mediafans betrokken bij verschillende crypto-start-upprojecten.</p>
<h2 id="h2-Ronaldinho626659"><a name="Ronaldinho" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ronaldinho</h2><p>Zoals we eerder hebben opgemerkt, is Ronaldinho betrokken bij verschillende cryptoprojecten en investeringsplatforms. Hij is een gerenommeerde voetballer die zijn eigen cryptocurrency-project genaamd Ronaldinho Soccer Coin (RSC) Project heeft gelanceerd. Zijn focus ligt op het maken van RSC tot een wereldwijde valuta voor sportactiviteiten. Enkele van de producten en diensten op het platform zijn sportweddenschappen en digitale stadions.</p>
<h2 id="h2-Roberto20Carlos574165"><a name="Roberto Carlos" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Roberto Carlos</h2><p>Roberto Carlos, een van de bekende Braziliaanse backs, heeft onlangs zijn eigen cryptocurrency genaamd RC3 gelanceerd, beschikbaar op het Rally-platform.</p>
<h2 id="h2-Antoine20Griezmann19256"><a name="Antoine Griezmann" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Antoine Griezmann</h2><p>Antoine Griezmann, nog een toonaangevende Franse voetballer, heeft ook cryptocurrency en blockchaintechnologie omarmd. Zo gebruikt hij zijn socialemediaplatforms om verschillende cryptoprojecten te promoten. Als gevolg hiervan heeft hij partnerschappen gesmeed met verschillende cryptobedrijven. Opnieuw staat hij bekend om zijn steun aan de Atletico Madrid Fan Token.</p>
<h2 id="h2-David20Barral255291"><a name="David Barral" class="reference-link"></a><span class="header-link octicon octicon-link"></span>David Barral</h2><p>Het verhaal van David Barral, een voormalige spits van Real Madrid B, betrokkenheid bij crypto en sport is interessant. Dit komt doordat hij de eerste speler is die accepteert <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> (BTC) als zijn salaris. Dit is significant omdat het de eerste cryptodeal betrof waarbij betalingen werden gedaan in digitale valuta in de geschiedenis van het Spaanse voetbal.</p>
<h2 id="h2-Paul20Pogba161977"><a name="Paul Pogba" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Paul Pogba</h2><p>Pogba staat bekend om het promoten van verschillende digitale projecten met zowel cryptocurrencies als niet-fungibele tokens. Zo is hij bijvoorbeeld ambassadeur geweest van Cryptodragons, wat echter voor ophef heeft gezorgd op sociale media, omdat veel investeerders hun geld hebben verloren doordat de digitale activa aanzienlijk in waarde zijn gedaald in de loop der jaren.</p>
<h2 id="h2-Conclusie960801"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Ronaldinho heeft zijn betrokkenheid ontkend <a href="https://www.gate.io/learn/articles/pyramid-and-ponzi-schemes/154" target="_blank">in een crypto-piramidespel</a> waar investeerders meer dan $61 miljoen verloren. Hij beweerde ook dat hij slachtoffer is van de zwendel die zijn afbeeldingen en naam zonder autorisatie heeft gebruikt. Ronaldinho is echter niet de enige voetballer die deelneemt aan crypto-projecten. Kylian Mbappe, Cristiano Ronaldo, Luis Suarez, Lionel Messi, Roberto Carlos en Antoine Griezmann zijn voorbeelden van andere voetballers die geïnteresseerd zijn in cryptocurrencies.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Mashell C.</strong>, Gate.io onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de opvattingen van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal er juridische stappen worden ondernomen vanwege auteursrechtinbreuk.<br></div><p></p><br></div></div></div>