QWFua2xhZ2VycyBiZXRvZ2VuIGRhdCB2b29ybWFsaWcgQ0VPIENaIHZhbiBCaW5hbmNlIGVlbiB2bHVjaHRyaXNpY28gdm9ybXQgZW4gdnJhZ2VuIG9tIHZhc3Rob3VkaW5nIGluIGRlIFZT

<p><img src="https://gimg2.gateimg.com/image/article/1701939785RDZZ 1.jpeg" alt=""></p>
<h2 id="h2-Te20lang20niet20gelezen485249"><a name="Te lang; niet gelezen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Te lang; niet gelezen</h2><p>Aanklagers in de VS geloven dat Changpeng Zhao mogelijk niet naar de Verenigde Staten zal terugkeren voor zijn veroordeling zodra hij het land verlaat.</p>
<p>Binance heeft Richard Tenge benoemd tot zijn nieuwe CEO.</p>
<p>Zhao zal in februari 2024 worden veroordeeld.</p>
<h2 id="h2-Introductie242592"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De Amerikaanse federale rechtbanken behandelen twee spraakmakende cryptozaken, een gaat over overtredingen van witwassen van geld en de andere over verduistering van klantengeld. Beide zaken betrekken topcrypto-uitwisselingen, Binance-uitwisseling en FTX, die in 2022 zijn ingestort. Twee oprichters en voormalige CEO’s staan terecht, Sam Bankman-Fried van FTX en Changpeng Zhao van Binance.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2250" target="_blank">Wat zijn cryptowalvissen en waarom zijn ze belangrijk</a></p>
<p>In dit artikel bespreken we het proces en de schuldbekentenis van Changpeng Zhao. We zullen ook ingaan op de toekomst van Binance na het aftreden van Zhao. Ten slotte zullen we kijken naar hoe Binance zich niet heeft gehouden aan de United States Bank Secrecy Act.</p>
<h2 id="h2-Amerikaanse20aanklagers20dringen20aan20op20beperkingen20voor20CZs20vertrek799060"><a name="Amerikaanse aanklagers dringen aan op beperkingen voor CZ’s vertrek" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Amerikaanse aanklagers dringen aan op beperkingen voor CZ’s vertrek</h2><p>De Amerikaanse aanklagers dringen er bij de federale rechtbank op aan om te beperken <a href="https://www.gate.io/blog_detail/139/r2f0zs5pbybpynnlcnzhdglvbjogvghlihrvccbzaxggy3j5chrvy3vycmvuy3kgbwfnbmf0zxmgyw5kihrozwlyihdhexmgdg8gz2v0ihjpy2gh" rel="nofollow noopener noreferrer" target="_blank" title="Changpeng Zhao (CZ), de oprichter van Binance">Changpeng Zhao (CZ), de oprichter van Binance</a>, om het land niet te verlaten vanwege het vluchtrisico. Ze roepen in feite op dat Zhao in de Verenigde Staten blijft tot februari 2024, wanneer hij zijn veroordeling krijgt voor aanklachten van schendingen van witwaspraktijken.</p>
<p>Onlangs heeft Zhao schuldig gepleit aan de beschuldigingen van schendingen van het witwassen van geld, die door de Commodity Futures Trading Commission tegen hem zijn ingediend. De Amerikaanse toezichthoudende instantie beweerde dat Zhao en Binance, de grootste cryptocurrency-beurs ter wereld, niet de vereiste programma’s voor het kennen van uw klant en het bestrijden van witwassen hebben geïmplementeerd.</p>
<p>De Commodity Futures Trading Commission heeft ook Binance en Zhao aangeklaagd wegens samenzwering om een ongelicentieerde geldtransactie te verrichten en schendingen van de Amerikaanse sancties. Opmerkelijk is dat Binance heeft toegegeven dat het heeft nagelaten verdachte transacties door verschillende door de VS gesanctioneerde groepen en landen, waaronder ae-Qaeda, Islamitische Staat en de al-Qassam Brigades van Hamas, te voorkomen en te melden.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/3487/daily-news-us-department-of-justice-responds-to-cz-incident-blast-mode-was-questioned-by-vc-institutions-dydx-1inch-and-other-tokens-see-large-unlocking-this-week" target="_blank">Amerikaanse ministerie van Justitie reageert op CZ-incident</a></p>
<p>Binance voerde ook zaken uit met Rusland en Iran, die op de Amerikaanse sanctielijst staan. Crypto-investeerders uit Cuba, Syrië en de bezette gebieden van Oekraïne voerden verschillende transacties uit op Binance, wat in strijd is met de wettelijke standpunten van de Verenigde Staten.</p>
<p>Als onderdeel van zijn schuldbekentenis heeft Changpeng Zhao ermee ingestemd een boete van $50 miljoen te betalen en af te treden als CEO van Binance. Net als Zhao heeft Binance in de VS toegegeven dat het zich schuldig heeft gemaakt aan witwaspraktijken.</p>
<p>Postend op zijn blog, <a href="https://www.binance.com/en/blog/leadership/binance-announcement-reaching-resolution-with-us-regulators-2904832835382364558" rel="nofollow noopener noreferrer" target="_blank">Binance zei</a>, “Vandaag zijn we verheugd u te kunnen informeren dat we overeenkomsten hebben bereikt met het Amerikaanse ministerie van Justitie, de Commodity Futures Trading Commission, het Office of Foreign Assets Control, en het Financial Crimes Enforcement Network met betrekking tot hun onderzoeken naar historische registratie-, nalevings- en sanctiekwesties.”<br>Het voegde eraan toe: “Deze overeenkomsten erkennen de verantwoordelijkheid van ons bedrijf voor historische, criminele nalevingsovertredingen en stellen ons bedrijf in staat om een uitdagend maar transformerend hoofdstuk van leren en groei af te sluiten.”</p>
<p>Ook plaatste Zhao op zijn X-profiel een bericht waarin hij zijn fouten erkende en de onmiddellijke weg vooruit aankondigde. <a href="https://twitter.com/cz_binance/status/1727063503125766367?s=12&amp;t=HxXmBivJv0_WMvW1VgpZlg" rel="nofollow noopener noreferrer" target="_blank">Hij schreef</a> Vandaag ben ik afgetreden als CEO van Binance. Toegegeven, het was emotioneel niet gemakkelijk om los te laten. Maar ik weet dat het de juiste beslissing is. Ik heb fouten gemaakt en ik moet verantwoordelijkheid nemen. Dit is het beste voor onze gemeenschap, voor Binance en voor mezelf.</p>
<h2 id="h2-Zhao20is20een20vluchtrisico20Aanklagers411366"><a name="Zhao is een vluchtrisico: Aanklagers" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Zhao is een vluchtrisico: Aanklagers</h2><p>Zoals hierboven aangegeven, is de belangrijkste reden dat de Amerikaanse aanklagers de federale rechtbank hebben verzocht om Zhao te weerhouden het land te verlaten, het risico op vlucht. De aanklagers hebben betoogd dat de Verenigde Arabische Emiraten, het land van verblijf van Zhao, geen nauwe banden heeft met de Verenigde Staten. Als gevolg hiervan zou Zhao mogelijk niet terugkeren als hij het land verlaat. Dit betekent niet dat Zhao moet worden vastgehouden voordat de rechter zijn straf uitspreekt.</p>
<p>Op basis van de huidige voorwaarden heeft Zhao het recht om de Verenigde Staten te verlaten nadat hij $15 miljoen heeft gestort op een trustaccount en een persoonlijke recognitieband ter waarde van $175 miljoen heeft ondertekend. Niettemin geloven de aanklagers dat Zhao zich mogelijk niet aan de overeenkomst houdt zodra hij het land verlaat. Dit komt doordat zijn vermogen buiten de Verenigde Staten ligt. Bovendien bestaat er geen huidige uitleveringsovereenkomst tussen de VS en de VAE.</p>
<p>Aan de andere kant hadden de advocaten van Zhao geldige argumenten voor de Verenigde Staten om hem toe te staan het land te verlaten en op de genoemde datum terug te keren. Ze hebben betoogd dat de familie van Zhao in de Verenigde Arabische Emiraten woont en het moeilijk voor hen is om binnen korte tijd naar de Verenigde Staten te verhuizen.</p>
<p>Ze betoogden ook dat omdat Zhao vrijwillig naar de Verenigde Staten kwam, hij geen vluchtrisico vormt. In plaats daarvan zal hij tegen 10 februari terugkeren naar het land. Het is belangrijk op te merken dat de voormalige CEO van Binance tot 18 maanden gevangenisstraf kan krijgen voor de misdrijven. Desalniettemin dringen de aanklagers aan op een zwaardere straf.</p>
<h2 id="h2-Richard20Teng20zal20het20hoofd20worden20van20Binance195408"><a name="Richard Teng zal het hoofd worden van Binance" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Richard Teng zal het hoofd worden van Binance</h2><p>Binance heeft de benoeming van Richard Tenge, voormalig hoofd van de regionale markten, tot nieuwe CEO aangekondigd. Het nieuws werd bekendgemaakt op het blog van Binance. <a href="https://www.binance.com/en/blog/leadership/binance-announcement-reaching-resolution-with-us-regulators-2904832835382364558" rel="nofollow noopener noreferrer" target="_blank">Binance zei</a> Met ingang van heden neemt Richard Teng, voorheen Global Head of Regional Markets bij Binance, het stokje over van CZ als CEO.</p>
<p>Voordat je lid werd van Binance <a href="https://www.binance.com/en/blog/leadership/binance-announcement-reaching-resolution-with-us-regulators-2904832835382364558" rel="nofollow noopener noreferrer" target="_blank">Teng was de CEO van de Financial Services Regulatory Authority bij Abu Dhabi Global Market</a>; de Chief Regulatory Officer van de Singapore Exchange (SGX) en de Director of Corporate Finance van de Monetary Authority of Singapore.”</p>
<h2 id="h2-Achtergrond20van20de20Binance20SECrechtszaak221571"><a name="Achtergrond van de Binance SEC-rechtszaak" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Achtergrond van de Binance SEC-rechtszaak</h2><p>Het onderzoek dat heeft geleid tot de huidige juridische strijd tussen Binance en verschillende Amerikaanse regelgevende instanties begon in 2018 toen het Ministerie van Justitie vermoedde dat de beurs zich schuldig maakte aan overtredingen van de regels inzake witwassen van geld. Sindsdien hebben verschillende Amerikaanse regelgevende instanties onderzoek gedaan naar Binance vanwege verschillende overtredingen.</p>
<p>Bijvoorbeeld heeft de Amerikaanse Securities and Exchange Commission (SEC) dit jaar een rechtszaak aangespannen tegen Binance wegens het exploiteren van een niet-geautoriseerde effectenbeurs.</p>
<p>Ook heeft de US Commodity Futures Trading Commission (CFTC) in maart van dit jaar Binance aangeklaagd wegens schending van de Commodity Exchange Act (CEA) en CFTC-regelgeving.</p>
<p><a href="https://www.cftc.gov/PressRoom/PressReleases/8825-23#:~:text=%5BSee%20CFTC%20Press%20Release%20No,required%20to%20provide%20any%20identity%2D" rel="nofollow noopener noreferrer" target="_blank">Volgens een recent persbericht</a> De CFTC-klacht beschuldigde Binance onder andere van het illegaal aanbieden en uitvoeren van transacties in commodity-derivaten aan en voor Amerikaanse klanten, en het accepteren van geld van die klanten, die voor het grootste deel van de relevante periode niet verplicht waren om enige identiteitsverificerende informatie te verstrekken voordat ze op het platform gingen handelen.</p>
<p>Het is tegen dergelijke aanklachten dat Binance en Zhao schuldig zijn bevonden aan overtredingen van het witwassen van geld in de VS.</p>
<h2 id="h2-Conclusie737206"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De Amerikaanse aanklagers hebben een Amerikaanse federale rechtbank verzocht om Changpeng Zhao te verbieden het land te verlaten, omdat hij een vluchtrisico vormt. Ondertussen hebben de advocaten van Zhao volgehouden dat de voormalige CEO van Binance op de afgesproken datum, 10 februari, naar de Verenigde Staten zal komen. Ondertussen heeft de beurs Richard Tenge aangesteld als de nieuwe CEO van Binance.</p>
<h2 id="h2-Veelgestelde20vragen20over20Binance20Exchange420633"><a name="Veelgestelde vragen over Binance Exchange" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over Binance Exchange</h2><h3 id="h3-Is20Binance20onder20SEConderzoek400990"><a name="Is Binance onder SEC-onderzoek?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is Binance onder SEC-onderzoek?</h3><p>De Amerikaanse regelgevende instanties hebben een schikking van $4 miljard getroffen met Binance, wat een einde zou moeten maken aan hun onderzoek naar de grootste cryptocurrencybeurs ter wereld. In juni 2023 klaagde de SEC Binance aan wegens het niet implementeren van een effectief antiwitwasprogramma. Hoewel de SEC crypto-beurzen zoals Binance en Coinbase heeft aangeklaagd, zijn er nog verschillende andere beurzen zoals Gate.io die niet zijn onderzocht omdat ze voldoen aan de Amerikaanse cryptowetten.</p>
<h3 id="h3-Wat20is20er20aan20de20hand20met20Binance923737"><a name="Wat is er aan de hand met Binance?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is er aan de hand met Binance?</h3><p>Onlangs heeft Binance zich schuldig verklaard aan de aanklachten van schendingen van de antiwitwasregelgeving die de Commodity Futures Trading Commission tegen haar heeft ingediend. Als gevolg hiervan heeft zij een schikking getroffen met diverse toezichthoudende instanties om $4 miljard te betalen voor haar wangedrag. Hoewel de SEC en andere Amerikaanse toezichthoudende instanties verschillende crypto-beurzen en projecten hebben aangeklaagd, heeft zij nog geen rechtszaken aangespannen tegen Gate.io en andere beurzen die voldoen aan haar wettelijke richtlijnen.</p>
<h3 id="h3-Waarom20is20Binance20niet20legaal20in20de20VS693086"><a name="Waarom is Binance niet legaal in de VS?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom is Binance niet legaal in de VS?</h3><p>Binance US is legaal in de Verenigde Staten, maar het heeft beperkte functies en producten in de aanbieding. De wetten van de Verenigde Staten vereisen dat alle crypto-uitwisselingen die in het land actief zijn, zich aan de bepalingen houden. Gate.io is een andere toonaangevende beurs die legaal is in de Verenigde Staten en voldoet aan de regels voor crypto.</p>
<h3 id="h3-Is20Binance20geld20witwassen400096"><a name="Is Binance geld witwassen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is Binance geld witwassen?</h3><p>Binance wast geen geld wit. Het heeft echter wel toegestaan dat gesanctioneerde Amerikaanse organisaties en landen zijn platform gebruikten om geld te sturen. Sommige van deze groepen en individuen waren betrokken bij witwasactiviteiten. In tegenstelling tot Binance voldoet Gate.io aan de antiwitwasregelgeving van de Verenigde Staten.</p>
<h3 id="h3-Waarom20onderzoekt20de20SEC20Binance780376"><a name="Waarom onderzoekt de SEC Binance?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom onderzoekt de SEC Binance?</h3><p>De SEC onderzoekt Binance om verschillende redenen, waaronder het exploiteren van een illegale effectenbeurs, het faciliteren van witwassen van geld en mogelijke onteigening van Amerikaanse crypto-activa. Een andere Amerikaanse overheidsinstantie, de Commodity Futures Trading Commission (CFTC), heeft de beurs al veroordeeld voor schendingen van de antiwitwasregels. Andere crypto-uitwisselingen zoals Gate.io die actief zijn in de VS zijn echter nooit onderworpen geweest aan een dergelijk onderzoek, omdat ze zich houden aan de wettelijke bepalingen.</p>
<h3 id="h3-Is20er20een20rechtszaak20tegen20Binance411671"><a name="Is er een rechtszaak tegen Binance?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is er een rechtszaak tegen Binance?</h3><p>Enkele Amerikaanse regelgevende instanties zoals de SEC en de Commodity Futures Trading Commission (CFTC) hebben rechtszaken aangespannen tegen Binance wegens schending van Amerikaanse crypto-gerelateerde voorschriften zoals de bepalingen inzake antiwitwassen en effectenwetten. Onlangs heeft Binance een schikking getroffen met Amerikaanse instanties waarbij het verplicht is om $4 miljard aan boetes te betalen.</p>
<h3 id="h3-Waarvan20wordt20Binance20beschuldigd455366"><a name="Waarvan wordt Binance beschuldigd?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarvan wordt Binance beschuldigd?</h3><p>Sommige Amerikaanse regelgevende instanties zoals de SEC en de Commodity Futures Trading Commission (CFTC) hebben Binance beschuldigd van het schenden van de crypto-gerelateerde regelgeving van het land, zoals de bepalingen inzake anti-witwassen. Hoewel Binance van dergelijke overtredingen is beschuldigd, zijn cryptocurrency-uitwisselingen zoals Gate.io vrij van dergelijke kosten omdat ze zich aan zijn wetten houden.</p>
<h3 id="h3-Wordt20crypto20in20de20gaten20gehouden20door20de20SEC700094"><a name="Wordt crypto in de gaten gehouden door de SEC?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wordt crypto in de gaten gehouden door de SEC?</h3><p>De SEC houdt toezicht op cryptocurrencies die zij beschouwt als effecten, zoals SOL en FIL. Het reguleert echter geen crypto-activa die het heeft aangewezen als grondstoffen.</p>
<h3 id="h3-Zal20Binance20rapporteren20aan20de20IRS791930"><a name="Zal Binance rapporteren aan de IRS?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Zal Binance rapporteren aan de IRS?</h3><p>De Verenigde Staten eist dat Binance cryptocurrency-transacties die de vastgestelde waarden overschrijden, rapporteert aan de IRS. Het is belangrijk om op te merken dat Binance in het verleden niet verplicht was om aan de IRS te rapporteren. Over het algemeen rapporteren alle gecentraliseerde beurzen die in de Verenigde Staten opereren aan de IRS en/of identificeren ze de KYC van hun 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 standpunten 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 op voorwaarde dat Gate.io wordt genoemd. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>