VHVya3NlIENyeXB0byBFeGNoYW5nZSBUaG9kZXggQ0VPIHZlcm9vcmRlZWxkIHRvdCAxMS4xOTYgamFhciBnZXZhbmdlbmlzc3RyYWY=

2023-09-19, 09:06

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""><br>Een Turkse rechtbank heeft Faruk Ozer, oprichter en voormalig CEO van Thodex, veroordeeld tot meer dan 11.000 jaar gevangenisstraf wegens fraude tegen investeerders.</p>
<p>Veel Turken investeren in cryptocurrencies om hun spaargeld te beschermen tegen hoge inflatie.</p>
<p>Crypto-investeerders moeten investeren in veilige, transparante en verantwoordelijke investeringsplatforms.</p>
<p>Trefwoorden: Turkse crypto exchange, crypto in Turkije, Faruk Ozer CEO, Thodex CEO, Thodex oprichter, Thodex exchange, Turkse crypto markt</p>
<h2 id="h2-Introductie390903"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Vanwege de hoge incidentie van crypto fraude en scams geven veel regeringen strenge straffen aan de daders. Een goed voorbeeld is de recente veroordeling van Faruk Ozer, oprichter en voormalig CEO van Thodex, tot meer dan 11.000 jaar gevangenisstraf. Deze post analyseert de omstandigheden die hebben geleid tot de ineenstorting van de Thodex crypto exchange en de impact van Ozer’s gevangenschap.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2129/gateio-committed-1m-to-turkey-earthquake-recovery-launches-charity-nft-collection" target="_blank">Gate.io heeft ₺1M toegezegd voor de herstelwerkzaamheden na de aardbeving in Turkije en lanceert een liefdadigheids-NFT-collectie.</a></p>
<h2 id="h2-De20ineenstorting20van20de20Thodexcryptobeurs383367"><a name="De ineenstorting van de Thodex-cryptobeurs" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De ineenstorting van de Thodex-cryptobeurs</h2><p>Faruk Özer, de oprichter en CEO van Thodex, werd veroordeeld tot 11.196 jaar, 10 maanden en 15 dagen gevangenisstraf vanwege zijn rol in de ineenstorting van de cryptobeurs. Volgens de Anatolische 9e Heavy Penal Court heeft Ozer meer dan 400.000 gebruikers voor meer dan $2 miljard aan cryptocurrencies opgelicht.</p>
<p>De rechtbank veroordeelt de voormalige CEO van Thodex samen met zijn belangrijkste handlangers, waaronder zijn broer Güven Özer en zus Serap Özer. Naast de gevangenisstraf heeft de Anatolische Negende Hoog Strafhof een boete van 135 miljoen lira opgelegd, ter waarde van ongeveer $5 miljoen, aan het trio.</p>
<p>Thodex, een grote Turkse crypto-uitwisseling, werd opgericht in 2017. Het groeide aanzienlijk tijdens 2020 en 2021 toen het duizenden cryptoinvesteerders aantrok die wilden profiteren van de cryptoboem. Aangezien de Turkse crypto-uitwisseling verschillende handelsparen aanbood, sloten veel handelaren, zowel amateurs als ervarenen, zich erbij aan.</p>
<p>Bovendien had het een zeer concurrerende gebruikersvriendelijke interface die geschikt was voor handelaren op verschillende niveaus van handelservaring. Niettemin staakte de Thodex-beurs plotseling haar activiteiten in 2021 zonder duidelijke verklaringen. In feite waren de redenen die het management gaf voor de sluiting van Thodex soms onovertuigend en tegenstrijdig.</p>
<p>Eerst zei het team dat er een ongedefinieerde investering was geweest die een tijdelijke pauze in de handel noodzakelijk had gemaakt. Op een ander moment zei Thodex CEO Ozer dat de beurs was aanglen door cyberaanvallen, wat resulteerde in het verlies van veel cryptocurrencies.</p>
<p>Niettemin speculeerden verschillende lokale publicaties dat de pauze in opnames en handel deel uitmaakte van een exit scam die CEO Faruk Ozer had bedacht. Vervolgens vluchtte Ozer naar Albanië waar hij twee jaar verbleef voordat hij werd gearresteerd en uitgeleverd aan zijn thuisland, Turkije. In feite heeft de Turkse regering Interpol ingeschakeld, die een rode melding tegen Ozer heeft gemaakt.</p>
<p>Al een groep Thodex-gebruikers heeft een zaak aangespannen tegen Ozer en zijn medewerkers, wat heeft geleid tot hun proces. Advocaat Oguz Evren Kilic vertegenwoordigde verschillende Thodex-klanten die geen toegang hadden tot hun cryptocurrencies op de beurs.</p>
<p>Lees ook <a href="https://www.gate.io/uk/article/31907 &quot;how to buy and sell crypto via Gate Turkey (GateTR" rel="nofollow noopener noreferrer" target="_blank">hoe u crypto kunt kopen en verkopen via Gate Turkey (GateTR)</a>”</p>
<h2 id="h2-De20juridische20zaak20tegen20voormalig20Thodex20CEO20Ozer561015"><a name="De juridische zaak tegen voormalig Thodex CEO, Ozer" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De juridische zaak tegen voormalig Thodex CEO, Ozer</h2><p>Toen Ozer in april van dit jaar aan Turkije werd uitgeleverd, werd hij door de politie vastgehouden in afwachting van zijn berechting voor zeven aanklachten, waaronder het oprichten van een cryptografische organisatie met als doel het plegen van misdrijven, het plegen van fraude met behulp van informatieen, het leiden van een criminele organisatie en het witwassen van de activa van klanten.</p>
<p>Toen de Turkse regering de criminele activiteiten van Ozer en zijn medewerkers ontdekte, arresteerde de politie de broer van Ozer, zijn zus en vier andere mensen. In de loop van de tijd werden 83 mensen vastgehouden om het onderzoek naar de Thodex-zaak te vergemakkelijken.</p>
<p>Na een volledig proces heeft het Anatolische 9e Zware Strafhof 16 van de 21 beschuldigden vrijgelaten wegens gebrek aan bewijs. Desalniettemin werden de andere beklaagden schuldig verklaard en kregen ze verschillende gevangenisstraffen.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2324/dont-do-what-this-turkish-nft-investor-did-so-you-dont-end-up-living-with-your-parents" target="_blank">Doe niet wat deze Turkse NFT-investeerder deed, zodat je niet eindigt met het leven bij je ouders</a></p>
<h2 id="h2-Verdediging20van20voormalig20CEO20van20Thodex20Crypto20Exchange691825"><a name="Verdediging van voormalig CEO van Thodex Crypto Exchange" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Verdediging van voormalig CEO van Thodex Crypto Exchange</h2><p>Ozer had een zwakke verdediging vanaf het begin, omdat hij werd gearresteerd terwijl hij zich in een ander land verstopte en vervolgens aan Turkije werd uitgeleverd. Zijn belangrijkste verweer was dat zijn familie tijdens het proces oneerlijk werd behandeld, omdat ze niets verkeerds hadden gedaan. Hij hield vol dat Thodex failliet was gegaan, wat leidde tot de sluiting ervan.</p>
<p>Het Analogue Agency citeerde hem als volgt: “Er is geen sprake van een criminele organisatie in Thodex. Ik ben slim genoeg om alle instellingen in de wereld te leiden. Dat blijkt wel uit het bedrijf dat ik op 22-jarige leeftijd heb opgericht. Als ik een criminele organisatie zou opzetten, zou ik niet zo amateuristisch te werk gaan.’’</p>
<p>Het feit dat de rechtbank Ozer een lange gevangenisstraf heeft gegeven, betekent dat ze zijn argument niet heeft geaccepteerd.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2303/svb-crash-caused-the-butterfly-effect-in-the-crypto-market-what-should-investors-do" target="_blank">SVB Crash veroorzaakte het vlindereffect op de cryptomarkt</a></p>
<h2 id="h2-Betekenis20van20Thodex20in20Turkije20en20de20wereldwijde20cryptomarkt490277"><a name="Betekenis van Thodex in Turkije en de wereldwijde cryptomarkt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Betekenis van Thodex in Turkije en de wereldwijde cryptomarkt</h2><p>De ineenstorting van Thodex heeft veel Turkse burgers niet weerhouden van het gebruik van cryptocurrencies vanwege verschillende factoren, waaronder de hoge inflatie in het land. Inflatie heeft in feite al lange tijd dubbele cijfers bereikt. Als gevolg hiervan zijn veel Turken overgestapt op cryptocurrencies om de waarde van hun spaargeld te behouden.</p>
<p>De heer Kilic, de advocaat die een groep voormalige Thodex-klanten vertegenwoordigde tijdens het proces van Ozer, zei: ‘In zulke crisistijden willen mensen het waardeverlies van hun bezittingen verminderen.’ Sommige analisten geloven dat het inflatiepercentage van de Lira in maart hoger was dan de officieel vermelde 16%, wat laat zien hoe ernstig de situatie in het land is.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/1806/ftx-s-collapse-affected-a-wide-cross-section-of-the-crypto-eco" target="_blank">De ineenstorting van FTX heeft een breed scala van het cryptosysteem beïnvloed</a></p>
<p>Volgens een enquête, getiteld “Understanding Cryptocurrency Users”, uitgevoerd door <a href="/price/kucoin-kcs" rel="nofollow noopener noreferrer" target="_blank">KuCoin</a> De helft van de volwassen Turken investeert in cryptocurrencies. Het laat ook zien dat de adoptie van crypto-activa is toegenomen met tussen de 40% en 52% sinds 2021.</p>
<p>Bovendien gaf ongeveer 58% van de enquête deelnemers aan dat ze investeren in cryptocurrency om hun rijkdom te vergroten, terwijl 37% aangaf dit te doen als bescherming tegen inflatie. Over het algemeen hanteert de Turkse crypto-markt de koop-en-vasthoud-strategie om de waarde van hun financiële middelen te behouden. Als zodanig richten ze zich niet op het behalen van snelle rendementen uit hun crypto-investeringen.</p>
<p>Indicatief zullen de Turken waarschijnlijk de lange gevangenisstraf voor Ozer beschouwen als een sterke afschrikking voor andere Turkse burgers die crypto-investeerders in het land zouden willen oplichten. Over het algemeen zijn lange gevangenisstraffen gebruikelijk in het land. Afgezien van Ozer zijn er ook andere veroordeelde criminelen die lange gevangenisstraffen hebben gekregen.</p>
<p>Als voorbeeld veroordeelde een rechtbank in Turkije in 2016 Fethullah Gülen, een tegenstander van president Recep Tayyip Erdoğan, tot 1.900 jaar gevangenisstraf. Op dezelfde manier kreeg Adnan Oktar, veroordeeld voor een aantal misdaden, waaronder seksuele misdrijven, een gevangenisstraf van 8.600 jaar.</p>
<p>Niettemin hebben crypto-investeerders in Turkije en andere landen verschillende lessen getrokken uit dit incident. Beleggers moeten voorzichtig zijn bij het kiezen van hun investeringsplatforms om vergelijkbare financiële verliezen te voorkomen. Ze moeten investeren in platforms die transparant, veilig en verantwoordelijk zijn.</p>
<p>Bovendien zouden overheden hun toezicht op bedrijven die crypto-gerelateerde investeringsproducten en -diensten aanbieden moeten vergroten. In de toekomst zullen veel regeringen waarschijnlijk ervoor zorgen dat cryptocurrency-uitwisselingen die in hun landen opereren gereguleerd en veilig zijn.</p>
<h2 id="h2-De20noodzaak20om20te20investeren20in20veilige20en20transparante20cryptocurrencybeurzen944159"><a name="De noodzaak om te investeren in veilige en transparante cryptocurrency-beurzen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De noodzaak om te investeren in veilige en transparante cryptocurrency-beurzen</h2><p>Na bespreking van de ineenstorting van Thodex en de daaropvolgende arrestatie en veroordeling van Faruk Ozer, is het belangrijk om te benadrukken dat er verschillende gecentraliseerde crypto-uitwisselingen zijn zoals Gate.io die veilig en transparant zijn.</p>
<p>Naast het beveiligen van uw crypto-investeringen heeft de Gate.io-beurs bijvoorbeeld andere financiële voordelen, zoals haar <a href="https://www.gate.io/blog_detail/2216/how-to-benefit-from-gateios-token-reward-program" target="_blank">Token Beloningsprogramma</a>, ontworpen om gebruikersbetrokkenheid en loyaliteit te vergroten.</p>
<p>In feite verdienen Gate.io-gebruikers verschillende tokens wanneer ze deelnemen aan verschillende activiteiten op het platform, waaronder cryptocurrency-handel, het doorverwijzen van nieuwe gebruikers naar het platform en andere gerelateerde activiteiten. De investeerders zullen de verdiende tokens gebruiken om te betalen voor verschillende activiteiten. Bijvoorbeeld, ze kunnen ze gebruiken om te betalen voor hun notering, opname- en handelskosten.</p>
<h2 id="h2-Conclusie266219"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Een Turkse rechtbank veroordeelde de oprichter en voormalig CEO van Thodex tot meer dan 11.000 jaar gevangenisstraf voor verschillende misdaden die hij pleegde tijdens het runnen van de crypto-uitwisseling. Hij werd aangeklaagd voor het oprichten van een crypto-organisatie met als doel het plegen van misdaden, het plegen van fraude met behulp van informatieen, het leiden van een criminele organisatie en het witwassen van activa van klanten.</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 mening van de onderzoeker en vormt geen investeringssuggesties.<br></em><div><em></em>Gate.io behoudt zich alle rechten op dit artikel voor. Herplaatsing van het artikel is toegestaan, op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>