V2Fhcm9tIHN0aWpndCBnb3VkIHRlcndpamwgQml0Y29pbiBuaWV0IHZvbGd0Pw==

2025-06-05, 11:23

<p><img src="https://gimg2.gateimg.com/image/btc202506051920056074257330.png" alt="">
</p><p>In juni 2025 stegen de internationale goudprijzen naar een historisch hoogtepunt van $3430 per ounce, met een stijging van meer dan 30% sinds het begin van het jaar. Ondertussen fluctueerde Bitcoin, ook wel bekend als “digitaal goud”, naar beneden en vertoonde het een zwakke prestatie. Deze divergentie weerspiegelt een nieuwe speltheorie van wereldwijde kapitaal te midden van de renteverlagingcyclus van de Federal Reserve en geopolitieke onzekerheden.</p>
<h2 id="h2-De20macrologica20van20de20stijging20van20de20goudprijzen27834"><a name="De macro-logica van de stijging van de goudprijzen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De macro-logica van de stijging van de goudprijzen</h2><ol>
<li>Surge in Aankopen van Goud door Centrale Banken en De-dollarization van de Dollar: Centrale banken over de hele wereld verhogen hun goudreserves in een ongekend tempo, waarbij de centrale banken van China, India en Rusland gemiddeld meer dan 1.000 ton aankopen per jaar in de afgelopen drie jaar. Dit weerspiegelt systemische zorgen over de geloofwaardigheid van de dollar: acties zoals het bevriezen van de buitenlandse valutareserves van Rusland door de VS hebben landen ertoe aangezet hun aandeel dollarreserves te verminderen van 60% in 2022 naar de huidige 57%. Goud is de ultieme “beleid” geworden wanneer de soevereine kredietinstelling instort.</li><li>Federal Reserve Renteverlagingen en Dollarzwakte: De CME FedWatch Tool toont aan dat de kans op een renteverlaging in september 100% heeft bereikt. De daling van de rente verzwakt direct de aantrekkingskracht van de dollar, terwijl goud in dollars een natuurlijke waardestijging krijgt. Historische gegevens geven een significante negatieve correlatie aan tussen goud en rentevoeten - in een omgeving met lage rentevoeten dalen de rendementen op obligaties, en zijn fondsen meer geneigd om <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">stroom</a> in goud, dat geen rendement oplevert maar waarde behoudt.</li><li>Technische arbitrage veroorzaakt door tariefverwachtingen: Na de overwinning van Trump stegen de zorgen over invoertarieven op edelmetalen in de markt. Amerikaanse handelaren haastten zich om “voorraad aan te leggen” van spotgoud, waardoor het prijsverschil tussen COMEX-goudfutures en de Londen-goudprijs tijdelijk meer dan $70/ons overschreed. Arbitrageurs op de cross-markt stroomden binnen: ze kochten fysiek goud in Londen om naar New York te verschepen terwijl ze futures shortten om winst te vergrendelen. Binnen drie maanden stegen de COMEX-goudvoorraden met 101% en werden de futuresprijzen voortdurend omhooggedreven.</li></ol>
<h2 id="h2-Het20onderscheid20tussen20veilige20havens20en20risicovolle20activa135186"><a name="Het onderscheid tussen veilige havens en risicovolle activa." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het onderscheid tussen veilige havens en risicovolle activa.</h2><ul>
<li>Het voordeel van de “dubbele eigenschappen” van goud: In tegenstelling tot cryptocurrencies heeft goud zowel investerings- als consumptie-eigenschappen - de vraag naar gouden sieraden is goed voor 48% van de wereldwijde jaarlijkse vraag, terwijl technologische toepassingen goed zijn voor 7%. Deze gediversifieerde vraagstructuur biedt ondersteuning tijdens economische turbulentie, waardoor het vaak in de tegenovergestelde richting stijgt wanneer de Amerikaanse aandelen dalen.</li><li>Het “risico-actief” label van Bitcoin: De 30-daagse correlatie tussen <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en de Nasdaq-index is zo hoog als 0,82. Wanneer institutionele handelsafdelingen worden geconfronteerd met fluctuaties op de Amerikaanse aandelenmarkt, verkopen ze vaak <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> om aan marginvereisten te voldoen. In maart 2025, terwijl goud met 16% steeg, daalde Bitcoin met 6%, wat de logische diverge tussen de twee benadrukt.</li></ul>
<h2 id="h2-De20uitdagingen20en20kansen20van20digitaal20goud421410"><a name="De uitdagingen en kansen van “digitaal goud”" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De uitdagingen en kansen van “digitaal goud”</h2><p>Hoewel Bitcoin in bepaalde scenario’s (zoals de overdracht van activa door Turkse inwoners via Bitcoin tijdens het Rusland-Oekraïneconflict) zijn eigenschappen als veilige haven toont, liggen de kernbelemmeringen op twee punten:</p>
<ol>
<li>Volatiliteit verplettert goud: De wekelijkse volatiliteit van Bitcoin is 4,5 keer die van goud, met een gemiddelde daling van &gt;2,5% die eens in de vier weken voorkomt, terwijl de Value at Risk (VaR) tot 5 keer die van goud is. Dit ondermijnt de geloofwaardigheid als een “opslag van waarde” voor conservatieve fondsen.</li><li>Het verhaal steunt op beleidsdividenden: De stijging van Bitcoin eerder dit jaar was voornamelijk te wijten aan de goedkeuring van de Bitcoin spot ETF in de Verenigde Staten, wat honderden miljarden dollars aan extra fondsen heeft binnengebracht. Echter, nadat de “Trump-handel” (die beloofde een einde te maken aan de aanpak van cryptocurrencies) volledig door de markt was ingeprijsd, ontbrak het aan blijvende momentum. Daarentegen wordt de stijging van goud ondersteund door structurele vraag, zoals aankopen door centrale banken (goed voor 23%).</li></ol>
<h2 id="h2-Gegeneraliseerde20Toewijzing20Hedgingstrategien20voor20Web3investeerders752190"><a name="Gegeneraliseerde Toewijzing: Hedgingstrategieën voor Web3-investeerders" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gegeneraliseerde Toewijzing: Hedgingstrategieën voor Web3-investeerders</h2><p>Voor cryptocurrency-investeerders is de stijging van goud geen concurrerend signaal, maar een risico-waarschuwing:</p>
<ul>
<li>Arbitragetekenen voor on-chain goudtokens: De goudtoken PAXG stijgt in tandem met de spotgoudprijzen, terwijl het prijsverschil met Bitcoin groter wordt, wat kansen biedt voor cross-asset hedging. Op 2 juni, toen goud met 1,2% steeg, nam PAXG/USD met 1,5% toe, terwijl BTC met 0,5% daalde.</li><li>Voorraden van indicatoren voor trends in soevereine fondsen: Als de VS 17% van zijn goudreserves (ongeveer $171,8 miljard) verkoopt, kan het verschuiven naar de allocatie van Bitcoin. Trump heeft de “Strategic Bitcoin Reserve Executive Order” ondertekend, die, indien geïmplementeerd, de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">cryptovaluta markt</a> landschap.</li></ul>
<h2 id="h2-Conclusie20Complementair20in20plaats20van20substitutief689448"><a name="Conclusie: Complementair in plaats van substitutief" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie: Complementair in plaats van substitutief</h2><p>Goud doorbreekt eerdere hoogtepunten terwijl Bitcoin stagneert, wat in wezen de divergentie tussen “kredietafdekking” en “liquiditeitsspellen” weerspiegelt. Wanneer de Amerikaanse schuld meer dan $35 biljoen bedraagt (toenemend met $1 biljoen elke honderd dagen), weerspiegelen beide de vraagtekens bij het fiat-valutasysteem, maar spelen ze verschillende rollen: goud fungeert als het ballast tegen de kredietinstorting, terwijl Bitcoin optreedt als de ontvanger van liquiditeitsoverschot.</p>
<p>naar <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> Investeerders zouden hun posities in PAXG en andere goudgedekte activa moeten verhogen + dollar-cost averaging in Bitcoin spot ETF’s om een contracyclische portefeuille te vormen. Het ware verhaal van “digitale goud” begint net nu de kloof tussen de marktwaarde van goud (22,7 biljoen USD) en de marktwaarde van Bitcoin (2,1 biljoen USD) smaller wordt.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Blogteam</strong><br><div class="info-tips"><em>De inhoud hierin vormt geen aanbod, sollicitatie of aanbeveling. U dient altijd onafhankelijk professioneel advies in te winnen voordat u investeringsbeslissingen neemt.<br><div></div>Houd er rekening mee dat Gate het gebruik van alle of een deel van de Diensten vanuit Beperkte Locaties kan beperken of verbieden. Voor meer informatie, lees de Gebruikersovereenkomst via <a href="https://www.gate.com/legal/user-agreement" data-index="5">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>