Q2Vuc3V1ciB2YW4gaGV0IEJpdGNvaW4gRVRGIHZhbiBWYW5ndWFyZCB6b3JndCB2b29yIHZlcm9udHdhYXJkaWdpbmc=

2024-01-23, 06:52

<p><img src="https://gimg2.gateimg.com/image/article/1700024128RDZZ 1.jpeg" alt=""><br>Vanguard heeft investeerders geblokkeerd om spot te kopen <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETFs.</p>
<p>Verschillende investeerders hebben beloofd hun geld terug te trekken uit Vanguard en te investeren in andere vermogensbeheerders.</p>
<p>Het beleggingsbeleid van Vanguard is tegen het aanbieden van crypto-gerelateerde producten.</p>
<p>Trefwoorden: BTC ETF, <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> ETF, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a>, bitcoinhouders, uitsluiting van bitcoin, censuur van bitcoin, crypto-ETF’s, crypto-investeringen, verkoop van bitcoin, <a href="/how-to-buy/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Koop Bitcoin</a>, verbied spot bitcoin ETF</p>
<h2 id="h2-Introductie861915"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Het jaar 2024 begon goed wat betreft crypto-ontwikkelingen <a href="https://www.gate.io/blog_detail/3692/daily-news-the-sec-officially-approved-bitcoin-spot-etfs-btc-breaking-through-dollar47000-eth-exceeding-dollar2700-ens-increasing-by-over-30" target="_blank">na de goedkeuring van de SEC van 11 spot bitcoin ETF’s op 10 januari</a> De SEC heeft aanvragen goedgekeurd voor BTC ETF van 11 vermogensbeheerbedrijven, waaronder Fidelity, Invesco, BlackRock en Ark Investments, wat een podium biedt voor een enerverend 2024.</p>
<p>Nu is het volgende belangrijke stadium gerelateerd aan hoe de ETF’s zullen presteren op de markt en hoe de traditionele beurzen zullen profiteren van deze ontwikkeling. NYSE, Cboe en Nasdaq zijn enkele beurzen die de ETF’s aanbieden.</p>
<p>Het doel van dit artikel is om de redenen te analyseren waarom Vanguard heeft geweigerd om de spot bitcoin ETF’s te vermelden en de gevolgen daarvan voor de beurs.</p>
<p>Gerelateerd nieuws: <a href="https://www.gate.io/learn/articles/these-are-the-high-profile-spot-bitcoin-etf-applications-currently-in-pllay/1258" target="_blank">Dit zijn de high-profile spot Bitcoin ETF-aanvragen</a></p>
<h2 id="h2-Vanguard20blokkeert20toegang20tot20Bitcoin20ETFS20waardoor20klanten20massaal20vertrekken811891"><a name="Vanguard blokkeert toegang tot Bitcoin ETFS, waardoor klanten massaal vertrekken" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vanguard blokkeert toegang tot Bitcoin ETFS, waardoor klanten massaal vertrekken</h2><p>Vanguard, een van de toonaangevende beurzen in de Verenigde Staten, heeft aangegeven dat het niet bereid is om spot bitcoin exchange traded funds aan te bieden. Dit kwam als een verrassing voor veel investeerders, waaronder haar langdurige klanten, aangezien het wel andere exchange traded funds aanbiedt die verband houden met aandelen, indices en obligaties.</p>
<p>Vanguard, het op één na grootste vermogensbeheerbedrijf na Blackrock, heeft zijn klanten geblokkeerd om toegang te krijgen tot de nieuw goedgekeurde spot bitcoin ETF’s. Belangrijker nog, het bedrijf heeft bevestigd dat het geen bitcoin ETF wil noteren, omdat dit niet overeenkomt met zijn beleggingsfilosofie.</p>
<p>Op donderdag 11 januari bevestigden veel X- en Reddit-gebruikers dat ze geen spot Bitcoin ETF’s kunnen kopen met hun Vanguard-accounts. Bijvoorbeeld, een X-gebruiker, Tony Spencer, die contact opnam met het vermogensbeheerbedrijf met betrekking tot spot Bitcoin ETF-aanbiedingen, werd geïnformeerd dat het bedrijf dergelijke producten niet aanbiedt.<br><img src="https://gimg2.gateimg.com/image/article/17059924291.png" alt=""><br>Bron: x.com</p>
<p>Een andere x-gebruiker, Matthew Moore, zei dat de klanten die hebben geprobeerd BTC ETF’s te kopen via hun <a href="https://twitter.com/MattMoore23/status/1745477394407031290" rel="nofollow noopener noreferrer" target="_blank">pensioenmakelaarrekeningen kregen het volgende bericht</a>:</p>
<p>“Kooporders worden momenteel niet geaccepteerd voor deze effecten. Effecten kunnen niet beschikbaar zijn voor aankoop bij Vanguard vanwege verschillende variabelen, waaronder regelgevingsbeperkingen, bedrijfsacties of verschillende handels- en/of afwikkelingsbeperkingen.”</p>
<p>TheBlock <a href="https://www.theblock.co/post/272049/vanguard-wont-offer-spot-bitcoin-etfs-says-high-volatility-is-bad-for-generating-long-term-returns" rel="nofollow noopener noreferrer" target="_blank">gerapporteerd dat</a> De censuur van Vanguard op bitcoin is te wijten aan de prijsvolatiliteit van de activa. Een vertegenwoordiger van het bedrijf zei dat bitcoin “zeer speculatief” en “ongereguleerd” is. Als gevolg hiervan past het niet bij het beleggingsbeleid.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/3707/bitcoin-etf-approval-analysts-weigh-in-on-implications" target="_blank">Bitcoin ETF-goedkeuring: analisten wegen de implicaties af</a></p>
<p>Volgens TheBlock, de <a href="https://www.theblock.co/post/272049/vanguard-wont-offer-spot-bitcoin-etfs-says-high-volatility-is-bad-for-generating-long-term-returns" rel="nofollow noopener noreferrer" target="_blank">een woordvoerder van het bedrijf verduidelijkte</a> De positie van het bedrijf. Hij/zij zei: “We hebben ook geen plannen om Vanguard Bitcoin ETF’s of andere crypto-gerelateerde producten aan te bieden - ons perspectief is al lang dat de hoge volatiliteit van cryptocurrencies ingaat tegen ons doel om beleggers te helpen positieve reële rendementen op lange termijn te genereren.”</p>
<p>Eric Balchunas, een ETF-analist bij Bloomberg, zei dat de positie van Vanguard ten opzichte van crypto ETF’s niet verrassend is gezien het feit dat de oprichter, John Bogle, in 2017 al <a href="https://www.bloomberg.com/news/articles/2017-11-28/vanguard-founder-jack-bogle-says-avoid-bitcoin-like-the-plague" rel="nofollow noopener noreferrer" target="_blank">gewaarschuwde investeerders</a> om Bitcoin te vermijden als de pest.</p>
<h2 id="h2-Marktreactie20op20de20uitsluiting20van20Vanguard20Bitcoin20ETF461183"><a name="Marktreactie op de uitsluiting van Vanguard Bitcoin ETF" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Marktreactie op de uitsluiting van Vanguard Bitcoin ETF</h2><p>Over het algemeen is het sentiment onder veel crypto-enthousiastelingen en vermogensbeleggers dat de onwil van traditionele beleggingsbedrijven om cryptobeleggingen zoals BTC ETF te omvatten, dergelijke bedrijven irrelevant kan maken voor de jongere generaties die geneigd zijn naar digitale activa. Zo kunnen de vermogensbeheerbedrijven die spot bitcoin ETF-producten verbieden op de lange termijn ‘verouderd’ worden.</p>
<p>Al geruime tijd roepen cryptocurrency-enthousiastelingen en investeerders om de opname van crypto-activa in de belangrijkste investeringslijnen. Daarom zijn bitcoin-houders … <a href="https://www.gate.io/learn/articles/regarding-bitcoin-spot-etf-5-key-information-that-you-must-pay-attention-to-now/1494" target="_blank">viering van de goedkeuringen van SEC’s BTC ETF</a>.</p>
<p>Als gevolg hiervan hebben sommige bitcoin maximalisten en analisten de crypto-ETF van Vanguard en de uitsluiting van bitcoin beschreven als een vorm van marktmanipulatie. Daarom voelen andere investeerders dat het bedrijf geen voeling heeft met de realiteit en de huidige investeringstrend, een reden waarom ze hun geld eruit halen.</p>
<p>Andere analisten hebben de oprechtheid en integriteit van Vanguard in twijfel getrokken voor de uitsluiting van bitcoin, aangezien het enkele beleggingsproducten aanbiedt van landen die de mensenrechten schenden, zoals Saoedi-Arabië en China.</p>
<p>Een x-gebruiker, Adam Cochran, heeft bitterheid getoond jegens Vanguard met betrekking tot zijn productbeleid en ethiek. Hij zei <a href="https://twitter.com/adamscochran/status/1745584935010738644" rel="nofollow noopener noreferrer" target="_blank">op x.com</a>,</p>
<p><strong>“Hey Vanguard Group, even ter verduidelijking, u haalt legitieme Bitcoin ETF’s van de beurs omdat het niet past bij uw “beleggingsfilosofie”. Maar u vindt het prima om $VWOB aan te bieden, wat obligaties zijn uit China, Saoedi-Arabië, Qatar en andere landen met uitgebreide schendingen van de mensenrechten en financiering van terroristen?”</strong></p>
<p>Hij vervolgde: “Jij als platform laat gebruikers kiezen of die investering geschikt voor hen is, maar nu neem je een vreemde morele hoogte in om gebruikerssoevereiniteit te negeren en als een voorschrijvende ouder te zijn?”</p>
<p>De tijd zal uitwijzen hoe het bedrijf het zal doen vanwege het beleid inzake digitale activa zoals bitcoin en de gerelateerde producten.</p>
<h2 id="h2-Uittocht20van20Vanguardklanten975334"><a name="Uittocht van Vanguard-klanten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Uittocht van Vanguard-klanten</h2><p>Vanwege de houding van Vanguard ten opzichte van crypto-ETF’s hebben veel beleggers beloofd hun investeringen uit het bedrijf terug te trekken en te investeren in beurzen die aan hun behoeften voldoen. Bijvoorbeeld, Yuga Cohler, senior engineering manager bij Coinbase, zei dat hij nu van plan is zijn Roth 401(k)-besparingen bij Vanguard om te zetten naar Fidelity, wiens spot bitcoin ETF op 10 januari werd goedgekeurd samen met 10 anderen.</p>
<p>Met betrekking tot dit, <a href="https://x.com/yugacohler/status/1745544705272648073" rel="nofollow noopener noreferrer" target="_blank">Cohler zei</a>, “Het paternalistische blokkeren van Bitcoin ETF’s door Vanguard past niet bij mijn beleggingsfilosofie.”</p>
<p>Een andere crypto-investeerder en bitcoin-commentator, Neil Jacobs, gaf ook aan dat hij zijn investering zal terugtrekken uit Vanguard. Commentaar op X <a href="https://x.com/NeilJacobs/status/1745482313322930221" rel="nofollow noopener noreferrer" target="_blank">zei hij</a>, “Verschrikkelijke zakelijke beslissing van Vanguard.”</p>
<p>Sam Callahan, een hoofdanalist op de markt bij Swan, adviseerde zelfs zijn volgers hoe zij hun geld kunnen overmaken van Vanguard. Callahan is van plan dezelfde fondsen te investeren in Fidelity’s spot bitcoin ETF. Hij zei <a href="https://twitter.com/samcallah/status/1745496267830989024" rel="nofollow noopener noreferrer" target="_blank">op x.com</a>,</p>
<p><strong>“Ik heb 8 jaar aan 401K-spaargeld bij Vanguard van mijn tijd als werknemer bij Google. Ik zal deze fondsen overzetten naar Fidelity.”</strong></p>
<p>Vanessa Harris, een voormalige klant van Vanguard, heeft vastgesteld dat ze haar geld al heeft verplaatst van de beleggingsmaatschappij. Naast de onwil van het bedrijf om spot bitcoin ETF’s aan te bieden, beschuldigt Harris het ervan de prijs van Bitcoin te manipuleren door alleen mensen toe te staan <a href="https://twitter.com/technologypoet/status/1745491728650424459" rel="nofollow noopener noreferrer" target="_blank">GBTC verkopen [Grayscale Bitcoin Trust], niet kopen</a>.”</p>
<p>Toch heeft volgens Charles Edwards, oprichter van Capriole Fund, Vanguard niet als enige beleggingsmaatschappij investeerders verboden om bitcoin ETF’s te kopen. <a href="https://twitter.com/caprioleio/status/1745558882909564933" rel="nofollow noopener noreferrer" target="_blank">Hij bevestigde dat UBS, Citi, Merrill, “Morgan Stanley en Edward Jones</a> hebben hun klanten niet toegestaan om bitcoin ETF’s te kopen. Daarom zijn er verschillende vermogensbeheerbedrijven die beleggers mogelijk niet toelaten om <a href="https://www.gate.io/learn/articles/what-is-a-bitcoin-etf/218" target="_blank">Koop en verkoop Bitcoin ETF’s</a>.</p>
<h2 id="h2-Conclusie796095"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Het censureren van spot bitcoin ETF’s door Vanguard heeft verontwaardiging veroorzaakt in de crypto-sector, waarbij veel investeerders dreigen hun fondsen terug te trekken bij het bedrijf. Sommige analisten hebben het bedrijf beschuldigd van marktmanipulatie en het hanteren van dubbele standaarden in zijn investeringsbeleid. Zo verbiedt het de aankoop en verkoop van crypto, terwijl het beleggingsactiva aanbiedt uit landen met slechte mensenrechtensituaties.</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 beleggingssuggesties.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>