I korthet
Under de senaste åren har debatten om dollarns framtid som dominerande världsvaluta tagit ny fart. Geopolitiska omvälvningar – från ökade spänningar mellan USA och Kina till sanktioner i spåren av kriget i Ukraina – har gett nytt liv åt spekulationer om en möjlig ”avdollarisering” av världsekonomin.1 Därtill spär utvecklingen på hemmaplan på diskussionen: dollarkursen har försvagats under det senaste halvåret och USA:s statsskuld växer snabbt, vilket göder farhågor om att dollarns internationella ställning kan komma att försvagas framöver.
<div class="kvartal-meta clearfix" style="color: ">Av <a href="https://kvartal.se/medverkande/roger-svensson/">Roger&nbsp;Svensson</a> | 2 juni 2025<div style="float: right;" class="social-top-wrapper closed no-comments"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fryktet-om-dollarns-dod-ar-betydligt-overdrivet%2F&amp;t=Ryktet+om+dollarns+d%C3%B6d%3Cbr%3E%C3%A4r+betydligt+%C3%B6verdrivet"    target="_blank"    class="fb-link"    title="Dela på facebook"><i class="fa fa-facebook ui transparent"></i></a><a href   = "https://twitter.com/intent/tweet?text=Ryktet+om+dollarns+d%C3%B6d%3Cbr%3E%C3%A4r+betydligt+%C3%B6verdrivet+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fryktet-om-dollarns-dod-ar-betydligt-overdrivet%2F"    target = "_blank"    class  = "tw-link"    title  = "Dela på X.com"><i class="exticon exticon-x-icon"></i></a></span><span class="share-inner"><a href   = "http://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fryktet-om-dollarns-dod-ar-betydligt-overdrivet%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Ryktet om dollarns död<br>är betydligt överdrivet&body=https://kvartal.se/artiklar/ryktet-om-dollarns-dod-ar-betydligt-overdrivet/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/179664/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a></span><a href="#share" class="share-expand "    title="Visa fler delningsalternativ"><i class="fas fa-share-square ui transparent"></i></a></div></div></div><div class="kv-art-ext-sep"></div><div class="mobile-share clearfix" style="margin-top: -10px; margin-bottom: 20px;"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fryktet-om-dollarns-dod-ar-betydligt-overdrivet%2F&amp;t=Ryktet+om+dollarns+d%C3%B6d%3Cbr%3E%C3%A4r+betydligt+%C3%B6verdrivet"    target="_blank"    class="fb-link"    title="Dela på facebook"><i class="fa fa-facebook ui transparent"></i></a><a href   = "https://twitter.com/intent/tweet?text=Ryktet+om+dollarns+d%C3%B6d%3Cbr%3E%C3%A4r+betydligt+%C3%B6verdrivet+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fryktet-om-dollarns-dod-ar-betydligt-overdrivet%2F"    target = "_blank"    class  = "tw-link"    title  = "Dela på X.com"><i class="exticon exticon-x-icon"></i></a></span><span class="share-inner"><a href   = "http://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fryktet-om-dollarns-dod-ar-betydligt-overdrivet%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Ryktet om dollarns död<br>är betydligt överdrivet&body=https://kvartal.se/artiklar/ryktet-om-dollarns-dod-ar-betydligt-overdrivet/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/179664/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a></span><a href="#share" class="share-expand "    title="Visa fler delningsalternativ"><i class="fas fa-share-square ui transparent"></i></a></div></div><div class="article-actions"><a href="/profile" class="kv-aa-profile"><svg aria-hidden="true">  <use href="#tf-ti-user"></use></svg><span>Profil</span></a><a href="#nyhetsbrevet" onclick="newsletter()" class="newsletter"><i class="fas fa-paper-plane"></i><span>Nyhetsbrev</span></a><a class="reading-time" title="Ungefärlig lästid"><i class="far fa-clock ui"></i><span>Lästid 15 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/88e8be48-ee64-471a-a470-0b0d604ca174"    target = "_blank"    class  = "screen-reader-friendly"    title. = "Version som fungerar bättre med skärmläsarprogramvara">  <i class="fas fa-volume-up"></i>  <span>Skärmläsarvänlig</span></a></div><div class="in-short-wrapper closed" id="in-short-179664">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "179664"></span>    <i class="themify-icon-icon fas fa-align-left"></i>    <span class="in-short-heading">I korthet</span>    <hr class="in-short-divider" />    <div class="in-short-text">    </div>  </div></div><div class="article-beginning ">Under de senaste åren har debatten om dollarns framtid som dominerande världsvaluta tagit ny fart. Geopolitiska omvälvningar – från ökade spänningar mellan USA och Kina till sanktioner i spåren av kriget i Ukraina – har gett nytt liv åt spekulationer om en möjlig ”avdollarisering” av världsekonomin.<sup>1</sup> Därtill spär utvecklingen på hemmaplan på diskussionen: dollarkursen har försvagats under det senaste halvåret och USA:s statsskuld växer snabbt, vilket göder farhågor om att dollarns internationella ställning kan komma att försvagas framöver.</p>
</div>
<div class="rest-of-article ">
<p>BRICS-länderna i synnerhet har diskuterat hur de kan minska sitt beroende av dollarn. På ett BRICS-toppmöte 2023 deklarerade <strong>Vladimir Putin</strong> att processen att överge dollarn i handel var ”oåterkallelig” och att den redan tagit fart.<sup>2</sup></p>
<p>Till och med idén om en gemensam valuta för BRICS har lyfts fram i den offentliga debatten, i syfte att utmana dollarns dominans.</p>
<p>Samtidigt ser vi konkreta försök från stormakter att handla i andra valutor än dollarn. Kina har successivt ökat användningen av sin egen valuta yuan i utrikeshandeln. Ryssland, å sin sida, har efter västvärldens sanktioner börjat styra om handel till rubel och yuan; landet har till och med gjort den kinesiska valutan till en av huvudpelarna i sin utrikeshandel och valutareserv.<sup>3</sup> Dessa initiativ har gett bränsle åt rubriker om att ”kung dollar” snart kan förlora sin krona.</p>
<p>Än så länge syns dock få tecken på något omedelbart tronskifte – dollarn utgör fortfarande runt 60 procent av världens valutareserver och används vid ungefär hälften av all global handel.<sup>4</sup> Ingen utmanare har lyckats matcha den unika kombination av volym, stabilitet, likviditet, geopolitiskt inflytande och förtroende som ligger till grund för dollarns ställning. Det leder oss till frågan: Vad krävs för att en valuta ska bli internationellt dominerande?</p>
<h2>Vad krävs för en världsvaluta?</h2>
<p>Ekonomisk teori pekar på att endast valutor som uppfyller ett antal kriterier kan nå status som globalt dominerande. En inflytelserik formulering av kraven gavs av ekonomhistorikern <strong>Barry Eichengreen</strong>, baserad på studier av dollarns och tidigare dominerande valutors framväxt. Förenklat krävs följande fem faktorer:</p>
<ol>
<li>Stor volym och utbredd användning: Valutan måste ges ut i mycket stora mängder för att möta efterfrågan vid internationella transaktioner. Om inte tillräckligt med pengar finns i omlopp kan den inte fungera som globalt smörjmedel för handel och finans.</li>
<li>Värdestabilitet: Valutan ska behålla sitt värde över tid. För historiska mynt betydde det stabil metallhalt; för moderna fiatvalutor innebär det låg och förutsägbar inflation samt ett förtroende för att utgivaren (staten/centralbanken) inte urholkar värdet.</li>
<li>Hög likviditet och låga transaktionskostnader: Det måste finnas djupa och effektiva finansiella marknader för valutan. Den ska vara lätt att köpa och sälja utan stora skillnader mellan köp- och säljkurs eller prisrörelser, och accepteras brett så att omräkning och växlingskostnader blir minimala.</li>
<li>Ekonomisk och militär styrka hos utgivaren: Stormaktsstatus hos landet eller imperiet bakom valutan är nästan en förutsättning. En stark ekonomi och/eller dominerande handelsnation, och i historisk kontext även militärmakt, borgar för att valutan inte kollapsar vid externa chocker eller kriser. Det krävs en globalt inflytelserik aktör som kan upprätthålla ett stabilt finansiellt system och inge förtroende om att skulder betalas.</li>
<li>Transparens och tillit: Förtroende är nyckeln – omvärlden måste lita på att valutautgivaren sköter sin kassa ärligt och kompetent. Det handlar om allt från politisk stabilitet och fungerande institutioner till öppenhet i penningpolitiken. Utan tillit från användarna (regeringar, investerare, företag) kan ingen valuta bli global standard.<sup>5</sup></li>
</ol>
<p>Dessa kriterier samverkar och förstärker varandra genom nätverkseffekter.<sup>6</sup> När en valuta redan används allmänt blir det rationellt för fler aktörer att också använda den, eftersom det då finns ett stort ekosystem av handlare, banker och investerare som accepterar den. Ju fler som är anslutna till samma ”valutanätverk”, desto mer minskar kostnaderna för handel och transaktioner med den valutan.</p>
<blockquote><p>Historiskt har ett fåtal valutor uppnått status som världsvaluta.</p></blockquote>
<p>Historiskt har internationella handelsmän och handelshus ofta spontant konvergerat till att använda den mest stabila och likvida valutan i sin era, vilket minskade krånglet med växling och prisjämförelser. Nätverkseffekten skapar ett inbyggt monopol, där vinnaren tenderar att behålla sin dominans så länge grundförtroendet inte eroderar. Såväl handelshus som andra stater och centralbanker tenderar att understödja systemet genom att hålla den dominanta valutan som reservvaluta.<sup>7 </sup>Därmed kommer denna valuta att handlas till ett premium.</p>
<h2>Historiska lärdomar: från Roms denar till pundet</h2>
<p>Historiskt har ett fåtal valutor uppnått status som världsvaluta – accepterade långt utanför sina ursprungsländer. Redan under antiken cirkulerade exempelvis tetradrachmen – präglad av Aten och Makedonien – över stora områden.</p>
<p>Senare följde den romerska denaren, den bysantinska solidusen, den venetianska dukaten och det spanska silvret. På 1800-talet fungerade det brittiska pundet som global valuta. Gemensamt för dessa var att de backades av ekonomiskt och militärt starka riken och uppfyllde grundläggande kriterier – stor volym, stabilt värde, hög likviditet och låga transaktionskostnader, stark maktbas samt internationellt förtroende.<sup>8</sup></p>
<p>Den romerska denaren (silvermynt) blev kring Kristi födelse kanske världens första vitt spridda valuta. Romerska republiken och imperiet massproducerade denaren i stor skala och mynten höll stabil silverhalt under mer än 350 år. Denaren användes som räkneenhet i hela Romarriket och underlättade handel över ett enormt område. Likviditeten var hög och transaktionskostnaderna låga – en enda myntstandard inom imperiet gjorde växling onödig. Valutan stöddes av Romarrikets väldiga ekonomiska och militära makt, som garanterade dess värde och upprätthöll stabilitet genom Pax Romana. Denaren användes också utanför imperiet, bland annat i handel med Indien och Kina. Alla fem kriterier för en världsvaluta var därmed uppfyllda – fram till att Rom drabbades av kriser och myntdevalveringar på 200-talet e.Kr.<sup>9</sup></p>
<figure id="attachment_179876" aria-describedby="caption-attachment-179876" style="width: 942px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="wp-image-179876 size-full" src="https://kvartal.se/wp-content/uploads/2025/06/DENAR.png" alt="kvartal" width="942" height="481" data-wp-pid="179876" srcset="https://kvartal.se/wp-content/uploads/2025/06/DENAR.png 942w, https://kvartal.se/wp-content/uploads/2025/06/DENAR-300x153.png 300w, https://kvartal.se/wp-content/uploads/2025/06/DENAR-768x392.png 768w, https://kvartal.se/wp-content/uploads/2025/06/DENAR-600x306.png 600w" sizes="(max-width: 942px) 100vw, 942px" /><figcaption id="caption-attachment-179876" class="wp-caption-text">Denar präglad av kejsare Tiberius (14–37 e.Kr.). Källa: www.cngcoins.com</figcaption></figure>
<p>Det bysantinska guldmyntet Solidus tog vid där denaren slutade och dominerade handeln kring Medelhavet i nära sju sekler. Införd av kejsare Konstantin år 312 e.Kr. med ca 4,5 gram rent guld, blev solidusen grund för ett stabilt myntsystem. Bysantinska riket präglade stora volymer solidi som spreds över Europa och Mellanöstern. Strikt finanspolitik och god skatteförvaltning gjorde att guldhalten bibehölls från 300-talet till mitten av 1000-talet. Solidusen accepterades över kulturgränser – europeiska och arabiska köpmän litade på dess metallvärde – vilket gav låg friktion i handeln. Valutan backades av det östromerska rikets ekonomiska och militära styrka. Solidusen blev synonymt med pengar under tidig medeltid och betraktas som historiens mest långlivade internationella valuta (700 år), innan dess ställning försvagades med Bysans nedgång.<sup>10</sup></p>
<p>Under 1800-talet – guldmyntfotens och industrialiseringens era – övertog det brittiska pundet rollen som världens ledande valuta. Storbritannien var då världens främsta handels- och kolonialmakt, och pundet knöts till guld, vilket gav stabilitet. Volymen kunde hållas på en hög nivå genom att sedlar gavs ut som backades upp av guld. Londons banker och finansmarknader gav pundet oöverträffad likviditet. Brittiska imperiets globala räckvidd – skyddat av Royal Navy – ingav säkerhet. Pundet användes i internationell handel, som reservvaluta och som växelkursankare. Även institutionell trovärdighet och låg inflation bidrog till ett högt internationellt förtroende.<sup>11</sup> Pundets ställning var dock beroende av att Storbritannien bibehöll sitt ekonomiska och politiska övertag.</p>
<h2>Från pund till dollar</h2>
<p>Under 1900-talet skedde ett tronskifte. USA:s ekonomi växte om Storbritanniens kring sekelskiftet 1900 och fick övertag i industriproduktion och finansmarknader. Världskrigen försvagade Europa och tvingade britterna att överge pundets koppling till guld, vilket underminerade pundets förtroende.</p>
<figure id="attachment_179877" aria-describedby="caption-attachment-179877" style="width: 913px" class="wp-caption alignnone"><img decoding="async" class="wp-image-179877 size-full" src="https://kvartal.se/wp-content/uploads/2025/06/PUND.png" alt="kvartal" width="913" height="466" data-wp-pid="179877" srcset="https://kvartal.se/wp-content/uploads/2025/06/PUND.png 913w, https://kvartal.se/wp-content/uploads/2025/06/PUND-300x153.png 300w, https://kvartal.se/wp-content/uploads/2025/06/PUND-768x392.png 768w, https://kvartal.se/wp-content/uploads/2025/06/PUND-600x306.png 600w" sizes="(max-width: 913px) 100vw, 913px" /><figcaption id="caption-attachment-179877" class="wp-caption-text">Guldsovereign (1 brittisk pund) utgiven av Drottning Victoria (1837–1901). Källa: www.cngcoins.com</figcaption></figure>
<p>Redan efter första världskriget började dollarn gå om: sterling förlorade kampen mot dollarn i krigets efterspel. Efter andra världskriget stod USA som dominerande makt med industriell kapacitet, guldreserver och militärmakt.<sup>12</sup> Bretton Woods-systemet 1944 formaliserade dollarns centrala roll. Alla kriterier för världsvaluta var då uppfyllda av dollarn: stor volym, stabilitet, likviditet, geopolitisk styrka och förtroende. Dollarns dominans förstärktes dessutom av växande nätverkseffekter. Historien lär oss att valutors storhetstid inte varar för evigt – när makten och förtroendet skiftar, byter världen valutaspråk.</p>
<p>Statusen som världsvaluta innebär betydande ekonomiska fördelar för utgivaren. För USA innebär det bland annat:</p>
<ul>
<li>Stark valuta: Eftersom handelshus och andra stater håller den dominerande valutan som reserv, handlas den till ett premium. Detta ger det utgivande landet en stark köpkraft.</li>
<li>Lägre upplåningskostnader: Efterfrågan på amerikanska statspapper från utländska centralbanker pressar ner räntorna.<sup>13</sup></li>
<li>Valutafördelar i utrikeshandel: USA kan betala import i sin egen valuta, vilket andra länder inte kan.<sup>14</sup></li>
<li>Trygg hamn-effekt: Vid globala kriser flyr kapital till dollar snarare än från den, vilket minskar risken för valutakris.<sup>15</sup></li>
<li>Utrikespolitisk hävstång: Dollarns globala ställning ger USA inflytande över internationella transaktioner och möjliggör kraftfulla sanktioner.<sup>16</sup></li>
</ul>
<p>Dessa privilegier är inte gratisluncher utan kommer med visst ansvar och kostnader. Bland annat kan ett stort inflöde av utländskt kapital medföra överskott i USA:s finanser som måste absorberas, vilket tenderar att driva upp landets skuldsättning.<sup>17</sup></p>
<p>Trots det råder det ingen tvekan om att nettobalansen för USA är starkt positiv – världsvalutastatusen har gett USA en ekonomisk styrkeposition och handlingsfrihet som inget annat land åtnjuter.</p>
<h2>Utmanare till dollarn</h2>
<p>Hur står sig då dagens potentiella utmanare mot dollarn utifrån ovan kriterier? Låt oss granska kort några kandidater:</p>
<p>Kinas yuan. Kinas ekonomi är enorm (näst störst i världen), men yuanen har fortfarande begränsad spridning utanför Kina. Valutan är inte fritt konvertibel – omfattande kapitalregler och statlig kontroll innebär begränsad tillgång för omvärlden och därmed låg global likviditet. Detta undergräver volym- och likviditetskriterierna. Även förtroende saknas: det kinesiska finansiella systemet präglas av brist på transparens och osäkerhet kring rättssäkerhet och politiska ingrepp, vilket gör centralbanker ovilliga att hålla stora reservbelopp i yuan. Kina uppfyller volymkravet inom sin egen ekonomi, men utan öppenhet och internationell tillit förblir yuanen en regional valuta. Att yuanen ännu bara utgör 2–3 procent av de globala valutareserverna illustrerar dess begränsade roll.<sup>18</sup></p>
<p>EU:s euro är det starkaste alternativet till dollarn som internationell valuta. Euroområdet har en ekonomi i paritet med USA:s, och euron utgör 20 procent av världens reservvaluta-tillgångar. Värdestabiliteten är relativt god tack vare Europeiska centralbankens låginflationsmål, och euro-marknaderna är likvida. Trots detta brister euron i maktdimensionen: den backas inte av en enhetlig finanspolitik eller militär supermakt. EU är en union av suveräna stater – utan gemensam finanspolitik eller fullt integrerad försvarsstruktur – vilket innebär att euron saknar ett samlat ”imperium” med global räckvidd. Fragmenteringen märks även finansiellt (splittrade obligationsmarknader i olika euroländer), vilket kan öka komplexiteten jämfört med USA:s enhetliga marknad. Tidvis har också kriser (eurokrisen 2010–2012) naggat förtroendet i kanten. Euron är utan tvekan världens näst viktigaste valuta, men för att faktiskt detronisera dollarn skulle det krävas en djupare europeisk integration till en verklig federation med samordnad ekonomisk politik – något som ligger långt fram i tiden, om det ens är politiskt möjligt.</p>
<p>Alternativa monetära system. I orostider lyfts ibland mer visionära alternativ till dollarn fram. Två ofta omtalade idéer är att återinföra en guldmyntfot eller att skapa en ny gemensam valuta för en grupp länder (som BRICS), frikopplad från dollarn. Dessa förslag är vanligen politiskt eller retoriskt motiverade, men mycket svåra att genomföra i praktiken.</p>
<blockquote><p>Trots viss uppmärksamhet i debatten kan inte heller kryptotillgångar som bitcoin ersätta dollarn som global valuta.</p></blockquote>
<p>Guld framhålls ofta som ett tidlöst värdeankare – flera centralbanker (särskilt i Kina, Ryssland och Indien) har köpt rekordmängder guld de senaste åren som ett alternativ till dollarn. Teoretiskt skulle en valuta knuten till guld uppfylla stabilitets- och förtroendekraven eftersom ädelmetallen står utanför enskilda staters kontroll. Men i modern ekonomi fungerar guld dåligt som transaktionsvaluta: det är opraktiskt för vardagliga betalningar och den fasta mängden guld begränsar penningmängdens volym i en växande världsekonomi. Bretton Woods-systemet (dollarn knuten till guld fram till 1971) var det senaste försöket med en global guldstandard – även då användes dock dollarn som praktiskt bytesmedel.</p>
<p>Idag ses guld framför allt som en sista trygg hamn för värde snarare än basen för ett nytt valutasystem.</p>
<p>Tanken på en gemensam BRICS-valuta dyker upp med jämna mellanrum. I teorin skulle en sådan valuta (ibland föreslagen som en ”BRICS-coin” kopplad till guld eller en råvarukorg) kunna fungera som alternativt värdelager och betalningsmedel utanför dollarns kontroll. I praktiken är detta avlägset.</p>
<h2>Andra utmanare</h2>
<p>BRICS-länderna har väldigt olika ekonomier och politiska system, vilket gör det näst intill omöjligt att enas om gemensam penningpolitik och stabilitetsmål. Tills vidare nöjer sig gruppen med att öka andelen handel som sker i respektive lokala valutor – exempelvis har vissa avtal träffats för att betala rysk oljeexport i indiska rupier eller kinesisk import i brasilianska real i stället för dollar. Sådana arrangemang minskar dollarns roll marginellt i bilateral handel, men ingen av dem etablerar någon ny global standard. Utan det breda nätverk av användare och det förtroende som omger dollarn är utsikterna för en rivaliserande världsomspännande valuta små.</p>
<p>Andra betydande valutor som japanska yen och brittiska pund spelar också roller internationellt, men i begränsad skala. Yenen står för 5–6 procent och pundet runt 5 procent av centralbankers reservtillgångar. Volymmässigt är dessa valutor alltså långt bakom dollarn. Yenen är viktig i Asien, men Japans stagnerande ekonomi och decennier av ultralåga räntor har minskat dess attraktionskraft. Pundet har ett historiskt skimmer, men Storbritanniens numera lilla andel av globala ekonomin och osäkerhet efter Brexit gör att pundet idag spelar en biroll. Schweizerfranc och vissa mindre länders valutor används som säkra hamnar i kriser, men ingen av dem kan aspirera på global dominans i bred skala.</p>
<p>Centralbanker har förvisso börjat diversifiera en del av sina reserver till en korg av ”mellanstora” valutor (kanadensisk och australisk dollar, schweizerfranc) för att sprida risk – men detta rubbar inte dollarns fundamentala förstaplats.<sup>19</sup> Ingen enskild utmanare kan erbjuda samma unika kombination av volym, stabilitet, likviditet, global maktställning och förtroende som dollarn erbjuder.</p>
<p>Trots viss uppmärksamhet i debatten kan inte heller kryptotillgångar som bitcoin ersätta dollarn som global valuta. Bitcoin uppfyller inte de grundläggande kriterierna: den är extremt volatil, har en begränsad volym och höga transaktionskostnader, samt saknar en utgivande institution som kan garantera värde eller agera vid kriser.</p>
<p>Dollarns dominans förblir därför intakt, tills vidare.</p>
<p>En potentiell framtida svaghet för dollarn är dock USA:s snabbt växande statsskuld. I dag uppgår statsskulden till runt 36 000 miljarder dollar – över 120 procent av USA:s bnp – efter att ha ökat kraftigt de senaste åren.<sup>20</sup> Trots att dollarn just nu är stark väcker detta skuldberg frågor om långsiktig hållbarhet och förtroende för den amerikanska ekonomin. Den nuvarande nivån på skulden är inget akut hot mot dollarns dominans, men den stadiga ökningen och de växande räntekostnaderna på skulden kan på sikt minska efterfrågan på amerikanska statsobligationer, höja de långa marknadsräntorna samt minska investerares tillit.</p>
<p>Om marknaden börjar ifrågasätta USA:s förmåga att hantera sin skuld finns risken att dollarns ställning gradvis försvagas. Detta kräver att den amerikanska regeringen på allvar börjar sanera det offentliga budgetunderskottet. Dollarns växelkurs kan mycket väl försvagas kraftigt under Trumps politiska kaos, men detta är inte samma sak som att dollarn förlorar sin dominans som världsvaluta.</p>
<h2>En robust valuta</h2>
<p>Dollarns ställning som världsvaluta vilar på robust grund, formad av både historiska tillfälligheter och uppfyllandet av grundläggande ekonomiska krav. Teorin om internationella valutors dominans – volym, stabilitet, likviditet, makt och förtroende – fungerar som en checklista där dollarn i dagsläget kryssar i varje ruta.</p>
<p>Utmanare som euron eller yuanen uppfyller vissa kriterier men inte alla, och nätverkseffekternas trögrörlighet gör att klotet fortsätter snurra i de gröna sedlarnas takt. Givet rådande trender och inga drastiska systemskiften kommer dollarn sannolikt att behålla sin världsvalutastatus inom överskådlig framtid.</p>
<p>Som <strong>Mark Twain</strong> kunde ha sagt om han var ekonom idag: Ryktena om dollarns död är betydligt överdrivna.</p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="179664">  <span class="button-inner-wrapper">    <span class="left-part">      <i class="ti-arrow-circle-down"></i>    </span>    <span class="right-part">      <span class="default-text">Se noter</span>      <span class="open-text">Visa mindre</span>    </span>  </span></a></p>
<div class="references">
<h3 id="noter" class="ref-heading" style="color: #000;;">Noter</h3>
<ol>
<li>Arslanalp m.fl. (2024) och <em>Reuters</em> (2025). Arslanalp, S., Eichengreen, B. &amp; Simpson-Bell, C. (2024). <em>Dollar Dominance in the International Reserve System: An Update</em>. <em>IMF Blog</em>. Tillgänglig här: <a href="https://www.imf.org/en/Blogs/Articles/2024/06/11/dollar-dominance-in-the-international-reserve-system-an-update#:~:text=Recent%20data%20from%20the%20IMF%E2%80%99s,this%20trend%2C%20which%20we%20had">https://www.imf.org/en/Blogs/Articles/2024/06/11/dollar-dominance-in-the-international-reserve-system-an-update</a> <em>Reuters</em> (2025). <em>Percent of Global FX reserves in Dollar Ticks Up, Amount Fall, IMF data Shows</em>. Tillgänglig här: <a href="https://www.reuters.com/markets/currencies/percent-global-fx-reserves-dollars-ticks-up-amounts-fall-imf-data-shows-2025-03-31/#:~:text=Image%3A%20Graphic%20shows%20just%20under,in%20GBP%2C%20JPY%20and%20CNY">https://www.reuters.com/markets/currencies/percent-global-fx-reserves-dollars-ticks-up-amounts-fall-imf-data-shows-2025-03-31</a></li>
<li><em>BizNews</em> (2024). <em>The Economist: Unveiling at BRICS Summit: Putin’s Plan to Defeat the Dollar</em>. Tillgänglig här: <a href="https://www.biznews.com/global-citizen/2024/10/21/economist-brics-summit-putins-plan#:~:text=At%20the%20BRICS%20summit%20in,cheaper%20alternative%20for%20emerging%20economies">https://www.biznews.com/global-citizen/2024/10/21/economist-brics-summit-putins-plan</a></li>
<li><em>Financial Times</em> (2023). <em>China-Russia: an Economic ’Friendship’ that Could Rattle the World</em>. Tillgänglig här: <a href="https://www.ft.com/content/19eb54ba-f6f7-48ba-a586-b8a113396955">https://www.ft.com/content/19eb54ba-f6f7-48ba-a586-b8a113396955</a></li>
<li>Arslanalp m.fl. (2024) och <em>Reuters</em> (2025). Arslanalp, S., Eichengreen, B. &amp; Simpson-Bell, C. (2024). <em>Dollar Dominance in the International Reserve System: An Update. IMF Blog</em>. Tillgänglig här: <a href="https://www.imf.org/en/Blogs/Articles/2024/06/11/dollar-dominance-in-the-international-reserve-system-an-update#:~:text=Recent%20data%20from%20the%20IMF%E2%80%99s,this%20trend%2C%20which%20we%20had">https://www.imf.org/en/Blogs/Articles/2024/06/11/dollar-dominance-in-the-international-reserve-system-an-update</a> <em>Reuters</em> (2025). <em>Percent of Global FX reserves in Dollar Ticks Up, Amount Fall, IMF data Shows</em>. Tillgänglig här: <a href="https://www.reuters.com/markets/currencies/percent-global-fx-reserves-dollars-ticks-up-amounts-fall-imf-data-shows-2025-03-31/#:~:text=Image%3A%20Graphic%20shows%20just%20under,in%20GBP%2C%20JPY%20and%20CNY">https://www.reuters.com/markets/currencies/percent-global-fx-reserves-dollars-ticks-up-amounts-fall-imf-data-shows-2025-03-31</a></li>
<li>Detta villkor tillagt i Svensson (2025).</li>
<li>Dowd &amp; Greenaway (1993). Dowd, K. &amp; Greenaway, D. (1993). <em>Currency Competition, Network Externalities and Switching Costs. The Economic Journal</em>, Vol. 103(420), 1180–1189.</li>
<li>Svensson, R. (2025). <em>Money without Borders. The History of International Currencies</em>, i Svensson, R. (red.), <em>Economic Perspectives of Monetary History</em>. Stockholm: The Swedish Numismatic Society. Forthcoming.</li>
<li>Eichengreen, B. (2020). <em>International Currencies in the Lens of History</em>, in Battilossi, S., Cassis, Y. &amp; Yago, K. (red.), <em>Handbook of the History of Money and Currency</em>. Singapore: Springer. Svensson, R. (2025). <em>Money without Borders. The History of International Currencies</em>, i Svensson, R. (red.), <em>Economic Perspectives of Monetary History</em>. Stockholm: The Swedish Numismatic Society. Forthcoming.</li>
<li>Svensson, R. (2025). <em>Money without Borders. The History of International Currencies</em>, i Svensson, R. (red.), <em>Economic Perspectives of Monetary History</em>. Stockholm: The Swedish Numismatic Society. Forthcoming.</li>
<li>Svensson, R. (2025). <em>Money without Borders. The History of International Currencies</em>, i Svensson, R. (red.), <em>Economic Perspectives of Monetary History</em>. Stockholm: The Swedish Numismatic Society. Forthcoming.</li>
<li>Eichengreen, B. (2020). <em>International Currencies in the Lens of History</em>, in Battilossi, S., Cassis, Y. &amp; Yago, K. (red.), <em>Handbook of the History of Money and Currency</em>. Singapore: Springer. Svensson, R. (2025). <em>Money without Borders. The History of International Currencies</em>, in Svensson, R. (red.), Economic Perspectives of Monetary History. Stockholm: The Swedish Numismatic Society. Forthcoming.</li>
<li>Eichengreen, B. &amp; Flandreu, M. (2008). ‘The Rise and the Fall of the Dollar (or When DiD the Dollar Replace the Sterling as the Leading International Currency?’. NBER Working paper No. 14154.</li>
<li>Choi, J., Dang, D., Kirpalani, R. &amp; Perez, D. (2024). E<em>xorbitant privilege and the sustainability of U.S. public debt. AEA Papers and Proceedings</em>, Vol. 114, 562–566.</li>
<li>IMF (2024).</li>
<li>Eichengreen, B. (2020). <em>International Currencies in the Lens of History</em>, i Battilossi, S., Cassis, Y. &amp; Yago, K. (red.), <em>Handbook of the History of Money and Currency</em>. Singapore: Springer.</li>
<li>Brookings (2024). <em>The changing role of the US dollar. Brookings Institution Explainer</em>. Tillgänglig här: <a href="https://www.brookings.edu/articles/the-changing-role-of-the-us-dollar/">https://www.brookings.edu/articles/the-changing-role-of-the-us-dollar/</a></li>
<li>Brookings (2024). <em>The changing role of the US dollar. Brookings Institution Explainer</em>. Tillgänglig här: <a href="https://www.brookings.edu/articles/the-changing-role-of-the-us-dollar/">https://www.brookings.edu/articles/the-changing-role-of-the-us-dollar/</a></li>
<li>Reuters (2025). <em>Percent of Global FX reserves in Dollar Ticks Up, Amount Fall, IMF data Shows.</em> Tillgänglig här: <a href="https://www.reuters.com/markets/currencies/percent-global-fx-reserves-dollars-ticks-up-amounts-fall-imf-data-shows-2025-03-31/#:~:text=Image%3A%20Graphic%20shows%20just%20under,in%20GBP%2C%20JPY%20and%20CNY">https://www.reuters.com/markets/currencies/percent-global-fx-reserves-dollars-ticks-up-amounts-fall-imf-data-shows-2025-03-31</a></li>
<li>Arslanalp, S., Eichengreen, B. &amp; Simpson-Bell, C. (2024). <em>Dollar Dominance in the International Reserve System: An Update</em>. <em>IMF Blog</em>. Tillgänglig här: <a href="https://www.imf.org/en/Blogs/Articles/2024/06/11/dollar-dominance-in-the-international-reserve-system-an-update#:~:text=Recent%20data%20from%20the%20IMF%E2%80%99s,this%20trend%2C%20which%20we%20had">https://www.imf.org/en/Blogs/Articles/2024/06/11/dollar-dominance-in-the-international-reserve-system-an-update</a></li>
<li><em>USA Facts</em> (2025): <a href="https://usafacts.org/answers/how-much-debt-does-the-us-have/country/united-states/">https://usafacts.org/answers/how-much-debt-does-the-us-have/country/united-states/</a></li>
</ol>
</div>
</div>
<div class="author-byline">Roger Svensson är docent i nationalekonomi. Han forskar om innovationer, entreprenörskap och historiska monetära system vid Institutet för Näringslivsforskning.
</div>
</div>

Redan prenumerant? Logga in här
3 månader
helt gratis
helt gratis
Ingen bindningstid
- Alla artiklar
- Alla poddar
- Kvartals app
- Reklamfritt
Till erbjudandet
