TGEgc2VudGVuemEgZGkgZXN0cmFkaXppb25lIGRlbCBjby1mb25kYXRvcmUgZGkgVGVycmFmb3JtIExhYnMgRG8gS3dvbiDDqCBzdGF0YSBudW92YW1lbnRlIGFubnVsbGF0YQ==

2024-02-22, 08:38

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR453723"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Ancora una volta, la Corte d’Appello montenegrina ha annullato l’ordine di estradizione di Kwon verso gli Stati Uniti.</p>
<p>Gli Stati Uniti hanno dato al Montenegro fino al 24 marzo per finalizzare il caso di estradizione di Kwon.</p>
<p>Do Kwon e la SEC degli Stati Uniti hanno presentato mozioni per il riassunto del caso SEC vs. Kwon.</p>
<h2 id="h2-Introduzione105770"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Il processo di Do Kwon, <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> Il fondatore di Luna, negli Stati Uniti, è stato ritardato a causa di problemi tecnici. In particolare, il Montenegro non ha ancora finalizzato il processo di estradizione a causa di ostacoli legali. Ad esempio, in diverse occasioni il team legale di Do Kwon ha contestato l’emissione dell’ordine di estradizione. In questo articolo, ci concentriamo sulla recente inversione del verdetto di estradizione di Kwon.</p>
<h2 id="h2-Do20Kwon20assicura20il20soggiorno20in20Montenegro20mentre20la20decisione20di20estradizione20della20Corte20Suprema2020messa20in20discussione734855"><a name="Do Kwon assicura il soggiorno in Montenegro mentre la decisione di estradizione della Corte Suprema è messa in discussione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Do Kwon assicura il soggiorno in Montenegro mentre la decisione di estradizione della Corte Suprema è messa in discussione</h2><p>Do Kwon batte nuovamente l’estradizione negli Stati Uniti poiché la Corte d’appello montenegrina ha annullato la decisione di estradizione. In una sessione del 7 febbraio 2023, la Corte d’appello montenegrina ha accettato l’appello presentato dalla difesa di Do Kwon.</p>
<p>Il tribunale ha annullato la decisione presa dall’Alta Corte di Podgorica il 29 dicembre 2023. Pertanto, il caso di Do Kwon sarà rinviato al tribunale di primo grado per un nuovo processo. Nella precedente udienza del tribunale, l’Alta Corte di Podgorica ha emesso un ordine di estradizione sulla base della conclusione che tutte le condizioni richieste fossero soddisfatte.</p>
<p>La decisione si basa sulle varie accuse penali mosse contro Kwon in Corea del Sud e sulle richieste degli Stati Uniti al Montenegro di estradarlo. Già la Securities and Exchange Commission (SEC) degli Stati Uniti ha presentato accuse penali contro Do Kwon. Ora, il 25 marzo è la scadenza per il governo del Montenegro per finalizzare la questione.</p>
<p>Notizie correlate: <a href="https://www.gate.io/blog_detail/3732/kwon-seeks-trial-reschedule-in-sec-vsterraform-labs-case" target="_blank">Kwon chiede il rinvio del processo in SEC vs Terraform Labs</a></p>
<p>Per l’annullamento del verdetto di estradizione, la Corte d’appello ha citato difetti procedurali da parte del tribunale inferiore, nonché la mancanza di motivazioni chiare per la decisione e una formulazione incomprensibile.</p>
<p>Inoltre, l’annullamento del verdetto di estradizione potrebbe essere di breve durata come quello avvenuto nel dicembre 2023. Di fatto, l’appello vinto da Kwon a novembre è stato successivamente annullato a dicembre quando l’Alta Corte del Montenegro, per la seconda volta, ha deciso che il verdetto di estradizione era valido.</p>
<p>Da lì, il team legale di Kwon ha presentato un’altra appello che il pannello della Corte d’Appello ha recentemente accettato. La continua debacle legata all’estradizione di Do Kwon di <a href="/price/terra-luna" target="_blank" class="blog_inner_link">Terra</a> negli Stati Uniti è seguita al crollo del <a href="https://www.gate.io/how-to-buy/terra-luna" target="_blank">stablecoin TerraUSD</a> a maggio 2022, che ha scatenato un lungo mercato ribassista.</p>
<p>Il fondatore di Terra Luna è stato arrestato in Montenegro nel marzo 2023 ed è stato accusato di aver utilizzato un passaporto falso nel tentativo di lasciare il paese. Anche se è stato rilasciato su cauzione di $436.000 a maggio, un tribunale del Montenegro lo ha condannato a quattro anni di prigione per falsificazione di documenti di viaggio. Anche se Kwon ha presentato appello contro questa sentenza, ha perso l’appello, portando al suo imprigionamento.</p>
<p>I ritardi nella finalizzazione dell’estradizione di Kwon negli Stati Uniti potrebbero creare sfide relative al suo processo nel caso contro la Securities and Exchange Commission (SEC) degli Stati Uniti. Già gli Stati Uniti hanno indicato che potrebbero condurre il processo di Kwon in sua assenza se i rinvii dell’estradizione continuano.</p>
<p>All’inizio del 2023, la Securities and Exchange Commission (SEC) degli Stati Uniti ha presentato una causa contro Kwon, accusandolo di aver orchestrato un’operazione fraudolenta di criptovaluta da miliardi di dollari in violazione delle leggi sui valori mobiliari del paese.</p>
<p>La SEC sostiene che Terraform Labs e Kwon hanno raccolto miliardi di dollari vendendo titoli crittografici non registrati, inclusa Luna. Afferma che quando Kwon e Terraform stavano promuovendo Luna hanno fornito agli investitori informazioni fuorvianti che hanno ingannato alcuni di loro ad acquistare il token.</p>
<p>Leggi anche: <a href="https://www.gate.io/explore/terra-luna" target="_blank">Il progetto Terra Luna si riprenderà mai?</a></p>
<p>Nonostante il tribunale del Montenegro abbia respinto l’estradizione di Do Kwon negli Stati Uniti, sia Kwon che la SEC hanno presentato mozioni per il giudizio abbreviato negli Stati Uniti poiché ciascuna delle parti ritiene di avere un vantaggio nel caso.</p>
<p>Nel frattempo, nel dicembre 2023, il Montenegro ha estradato Han Chang-joon, ex CFO di Terraform Labs e collega di Do Kwon, in Corea del Sud. Come nel caso di Do Kwon, <a href="https://www.gate.io/blog_detail/2026/brace-for-impact-a-guide-to-navigating-a-cryptocurrency-crash-in-2023" target="_blank">dopo il crollo di Terra Luna in Corea del Sud</a> e gli Stati Uniti hanno presentato accuse penali contro Chang-Joon.</p>
<p>In Corea del Sud è stato accusato di violazioni della Legge sul Mercato dei Capitali, della Legge sulle Pene Aggravate per i Crimini Economici Specificati e della Legge sulle Transazioni Finanziarie Elettroniche, che sono accuse molto gravi.</p>
<p>Il governo sudcoreano lo accusa di aver rappresentato in modo non veritiero informazioni riguardanti la fattibilità dei progetti di Terra. In realtà, Chang-joon faceva parte del team che ha promosso la stablecoin TerraUSD.</p>
<p>Leggi anche: <a href="https://www.gate.io/price-prediction/terra-luna" target="_blank">Previsione del prezzo di LUNA &amp; Forecast per il 2025, 2030</a></p>
<h2 id="h2-Conclusione915605"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>La Corte d’Appello del Montenegro ha annullato l’ordine di estradizione di Kwon negli Stati Uniti citando irregolarità nel processo legale. Ciò significa che il tribunale inferiore avrà un altro nuovo processo nel caso di Do Kwon. Nel frattempo, gli Stati Uniti hanno dato al Montenegro fino al 24 marzo per finalizzare l’estradizione del fondatore di Terra.</p>
<h2 id="h2-Domande20frequenti20su20Do20Kwon653524"><a name="Domande frequenti su Do Kwon" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti su Do Kwon</h2><h3 id="h3-Quale20legge20ha20infranto20Kwon586808"><a name="Quale legge ha infranto Kwon?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quale legge ha infranto Kwon?</h3><p>In Montenegro, Kwon ha infranto le leggi sull’immigrazione del paese quando ha cercato di lasciare il paese utilizzando documenti falsificati. Tuttavia, negli Stati Uniti, Kwon ha violato le leggi sui titoli quando ha venduto titoli di criptoattività non registrati.</p>
<h3 id="h3-Dov20Do20Kwon890790"><a name="Dov’è Do Kwon?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dov’è Do Kwon?</h3><p>Attualmente, Do Kwon si trova in Montenegro dove sta scontando una pena detentiva per l’uso di documenti di viaggio falsi. Montenegro sta anche elaborando il suo documento di estradizione. Sia la Corea del Sud che gli Stati Uniti hanno richiesto al paese di estradare Kwon.</p>
<h3 id="h3-Chi2020il20proprietario20di20Luna231446"><a name="Chi è il proprietario di Luna?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Chi è il proprietario di Luna?</h3><p>Do Kwon è il proprietario di Luna dal momento in cui ha fondato Terraform Labs, che ha sviluppato il protocollo blockchain Terra, TerraUSD e Luna. TerraUSD, che era una stablecoin algoritmica, è crollata nel 2022.</p>
<h3 id="h3-Perch20Do20Kwon2020in20difficolt45670"><a name="Perché Do Kwon è in difficoltà?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Perché Do Kwon è in difficoltà?</h3><p>Do kwon è in difficoltà per due motivi, l’uso di documenti di viaggio falsi e la vendita di titoli crittografici non registrati. Il Montenegro ha accusato Kwon di utilizzare documenti di viaggio falsi, mentre gli Stati Uniti hanno intentato una causa contro Kwon per la vendita di titoli crittografici non registrati.</p>
<h3 id="h3-Qual2020il20caso20contro20Do20Kwon678309"><a name="Qual è il caso contro Do Kwon?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Qual è il caso contro Do Kwon?</h3><p>La Securities and Exchange Commission (SEC) degli Stati Uniti ha intentato una causa contro Kwon, accusandolo e Terraform Labs di vendere titoli di criptovalute non registrati. Kwon affronterà il processo negli Stati Uniti per quel caso. Attualmente è detenuto in Montenegro scontando una pena detentiva per aver utilizzato documenti di viaggio fraudolenti.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Mashell C.</strong>, Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>