Är Vance kronprinsen?

<div class="kvartal-meta clearfix" style="color: ">Av <a href="https://kvartal.se/medverkande/karin-henriksson/">Karin&nbsp;Henriksson</a> | 18 augusti 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%2Far-vance-kronprinsen%2F&amp;t=%C3%84r+Vance+kronprinsen%3F"    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=%C3%84r+Vance+kronprinsen%3F+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Far-vance-kronprinsen%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%2Far-vance-kronprinsen%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Är Vance kronprinsen?&body=https://kvartal.se/artiklar/ar-vance-kronprinsen/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/184928/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%2Far-vance-kronprinsen%2F&amp;t=%C3%84r+Vance+kronprinsen%3F"    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=%C3%84r+Vance+kronprinsen%3F+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Far-vance-kronprinsen%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%2Far-vance-kronprinsen%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Är Vance kronprinsen?&body=https://kvartal.se/artiklar/ar-vance-kronprinsen/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/184928/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 7 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/d7371179-b41c-4eb7-bebd-7db39201b532"    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-184928">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "184928"></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 ">President Vance.</p>
<p>Rimligtvis har <strong>JD Vance</strong> viskat detta framför spegeln och tänkt tanken att det skulle bli verklighet om något skulle hända den 79-årige <strong>Donald Trump</strong>.</p>
</div>
<div class="rest-of-article ">
<p>De amerikanska vicepresidenterna har ett av världens otacksammaste uppdrag. I bästa fall är de informella rådgivare, i sämsta fall helt sidsteppade. Första gången utsåg Trump den väckelsekristne före detta guvernören i Indiana <strong>Mike Pence</strong> till vicepresident. Andra gången fastnade han överraskande för <strong>JD Vance</strong> – endast 40 år gammal och med ett och ett halvt år i senaten som enda politiska merit.</p>
<p>JD Vances bakgrund var dock välkänd i och med hans bästsäljande memoarer <em>Hillbilly elegy </em>(som analyseras i ett avsnitt av <em><a href="https://kvartal.se/artiklar/hillbilly-elegy-och-white-trash-kultur/">Ola Wongs bokklubb</a> </em>med <strong>Joakim Broman</strong> och <strong>Lapo Lappin </strong>som gäster). Boken tilltalade både vänstern och högern i USA med å ena sidan vittnesmål om misär, drogmissbruk och arbetslöshet i bergsområdet Appalacherna och, å den andra, budskap om att människorna där borde rycka upp sig i skoskaften. Som han själv hade gjort genom att ta värvning i marinkåren, komma in på elituniversitet, bli rik efter några år i ett riskkapitalbolag och satsa på politiken – om än med draghjälp av it-miljardären<strong> Peter Thiel</strong>.</p>
<h2>Omsvängningen om ”Amerikas Hitler”</h2>
<p><a href="https://www.newyorker.com/culture/the-lede/the-story-that-hillbilly-elegy-doesnt-tell">Granskningar</a> såväl under den hårda striden i senatsvalet i Ohio 2022 som inför presidentvalet 2024 visade att uppväxten inte varit fullt så fattig som man kunde få intryck av i boken och att vissa sakuppgifter inte stämde. Men det som så småningom väckte mer uppmärksamhet var <a href="https://www.politico.com/news/2024/07/15/jd-vance-donald-trump-comments-00168450">hans uttalanden</a> om det republikanska partiets de facto ledare – <strong>Donald Trump</strong>. Vance sa att han betraktade Trump antingen som ”ett cyniskt rövhål som <strong>Richard Nixon</strong>… eller att han är Amerikas <strong>Hitler</strong>”. Omsvängningen till Magaprofet måste betraktas som historisk även i USA, men Vance slingrar sig alltid ur frågor om detta med argumentet att han insåg att Trump var den ende som kunde bryta upp ingrodda skadliga liberala mönster och wokekultur.</p>
<blockquote><p>Skvallret i Washington gör gällande att Trump litar på Vance och att de talas vid så gott som dagligen.</p></blockquote>
<p>I vilken utsträckning JD Vances namn på valsedeln bidrog till Trumps valseger kan diskuteras. Många utsåg honom till vinnare i den enda – och städade – debatten mellan vicepresidentkandidaterna före valet i november. Men han är inte någon entusiasmerande folktalare och saknar den typ av amerikansk politikerkarisma som bränner igenom tv-rutor och bildskärmar.</p>
<p>Den interna dynamiken mellan president och vicepresident är särdeles knepig när presidenten heter Donald Trump och vill stå ensam i rampljuset. Mike Pence fick aldrig bli kronprins och JD Vance är det knappast heller. På sistone har det sett ut som om Trump vill hetsa fram en duell mellan honom och utrikesminister <strong>Marco Rubio</strong>. Men Vance navigerar mycket skickligare i den lilla världen i politikens Washington än vad den anonyme Mike Pence gjorde. Skvallret i Washington gör gällande att Trump litar på Vance och att de talas vid så gott som dagligen.</p>
<p>Först betraktades JD Vance som uttolkare av Trumpväljarnas inre, som <em>white trash</em>-expert om man så vill. Framöver kan hans framtid avgöras av huruvida Magabasen uppfattar honom som en av dem, eller bara som en blek kopia av Donald Trump. Vance excellerar i och för sig i ett trumpskt fack, att förvränga fakta på ett försåtligt sätt och puckla på medierna. Efter överenskommelsen mellan USA och EU om tullar nyligen skrev han:</p>
<p>”Den samlade europeiska pressen sjunger just nu presidentens lov, imponerade av den deal han förhandlade fram för alla amerikaner. I morgon kommer de amerikanska medierna tveklöst att ha rubriker som ’Donald Trump fick bara 99,9 procent av det han ville’.”</p>
<p>Det tydde på att Vance inte scannat av eller brydde sig om vad som sades och skrevs i de europeiska medierna om EU:s <strong>Ursula von der Leyen </strong>och hennes eftergiftspolitik mot Trump.</p>
<h2>Isolationist och intellektuell</h2>
<p>Utåt framstår Vance som Trumps bandhund och <em>troll-in-chief</em> på sociala medier. Han skällde ut européerna på den årliga säkerhetspolitiska konferensen i München, han stämde helhjärtat in i Trumps förolämpningar mot ukrainske presidenten <strong>Volodymyr Zelenskyj</strong> i Ovala rummet och han for till Grönland, som Trump vill lägga beslag på – trots att han inte var välkommen. På presskonferensen där syntes dock att Vance kände sig allt bekvämare i rollen. Hans hittills smidiga sätt gentemot de olika Magafalangerna tycks också ha fungerat. Utrikespolitiskt är han uttalad isolationist och har blivit känd för sin ofta citerade kommentar att han ”inte bryr sig ett smack om Ukraina”.</p>
<p>Attacken mot Iran förklarade han med att det var ett krig mot kärnenergiprogrammet, inte mot landet. Han stämmer in i Trumps retorik om tullarna som ett sätt att hindra övriga världen från att utnyttja USA, fast medger att det kan ta lite tid innan de utlovade nya välbetalda industrijobben kommer.</p>
<p>Under sommaren skickades Vance ut till USA:s rostbälte för att sälja in det stora skatte- och utgiftspaketet, döpt till <em>One Big Beautiful Bill </em>(OBBB)<em>.</em> Han fällde utslagsrösten i juli när Republikanerna klubbade igenom denna mycket omfattande lag, som i kombination med de dramatiska tullhöjningarna är ett enormt vågspel både med ekonomin och hela den amerikanska samhällsstrukturen. Demokraterna, som enhälligt röstade emot OBBB, betraktar i synnerhet nedskärningar i sjukvården som ett trumfkort inför nästa års mellanårsval.</p>
<p>”Vi kommer att belöna er för ert hårda arbete och vi kommer att belöna amerikanska företag för att de investerar i Amerika, inte i utländsk arbetskraft”, sa Vance på ett framträdande i en demokratisk kongressledamots distrikt.</p>
<h2>Relativt okänd och sjunkande opinionssiffror</h2>
<p>Exakt hur Vance tillbringar sina arbetsdagar är lite av ett mysterium. Utöver nyhetsrapporter om arga protester på ställen dit familjen – hustrun <strong>Usha</strong> och tre små barn – begett sig på korta semesterresor har det bara glunkats om att Vance varit på hemligt uppdrag för att träffa mediemogulerna <strong>Rupert</strong> och <strong>Lachlan Murdoch</strong>. Gissningarna gick ut på att han antingen försökte stoppa eller misslyckades med att stoppa Murdochägda <em>Wall Street Journals</em> scoop om relationerna mellan Trump och den dömde sexualförbrytaren <strong>Jeffrey Epstein</strong>.</p>
<p>Usha Vance, som är hindu och har indiska rötter och egna akademiska meriter, ska ha haft stort inflytande över hans utveckling till att bli den polerade intellektuelle politikern. Huruvida hennes invandrarbakgrund är negativ i Magaväljarnas ögon är okänt, men detsamma gäller ju <strong>Melania Trump</strong>.</p>
<p>Vance ingår i den nihilistiska, manliga tech-eliten men tonar ner det och trycker i stället på vikten av traditionella familjevärden. Han konverserar mycket ledigt kring det mesta, även religion, med omvändelsen häromåret till en numera växande konservativ strömning inom katolicismen. På vänstersajter tolkades Vances träff med ledaren för tyska AfD i februari som en bekräftelse på fascistiska böjelser, och i samband med påve <strong>Leo XIV</strong>:s installationsmässa i Rom i maj sade han att det är ”mycket, mycket farligt” att försöka smutskasta ett annat parti.</p>
<p>Det mesta talar för att Donald Trump är ett unikum. Ingen annan kommer i närheten av hans uthållighet, viljestyrka och nonchalanta inställning till sanning, moral och traditioner.</p>
<blockquote><p>Vance är inte rädd för att bege sig till fiendens kula – vilket jag bevittnade i en svart baptistkyrka.</p></blockquote>
<p>Ideologiskt står Vance mycket nära Trump, om abort, invandring, hbtqi, kryptovalutor, tullar, klimatförändringar, fossila bränslen, den federala staten och ”woke” rent allmänt.</p>
<p>En president Vance skulle bli mer konsekvent och mer välartikulerad. Hans åsikter karakteriseras som en blandning av populism, nationalism och social konservatism. Ibland har det talats om att han är en ledarfigur för en ny höger, <em>new right</em>, som vänder sig till arbetarklassen med löften om högre minimilön och att bevara pensioner och äldresjukvården, men så länge han är vicepresident måste han helhjärtat stötta Trump och OBBB.</p>
<p>Vance är inte rädd för att bege sig till fiendens kula – vilket jag bevittnade i en svart baptistkyrka i Harrisburg i Pennsylvania strax före valet i november. Han anlände på utlovat klockslag, var charmig, vältalig och underströk allt som pastorn och han var ense om, mest bättre skolor.</p>
<p>I amerikansk politik är det alltid presidentvalskampanj, och spekulationerna inför 2028 pågår redan för fullt med tal om JD Vance som den självklare republikanske kandidaten och det kan förstås ske om Magaväljarna tycker att de fått det bättre.</p>
<p>Om Trump skulle försvinna har Vance i alla fall hittills ingen större <em>goodwill</em> att falla tillbaka på. Han är relativt okänd, och <a href="https://civiqs.com/results/favorable_jd_vance?uncertainty=true&amp;annotations=true&amp;zoomIn=true&amp;net=false">opinionssiffrorna</a> har sjunkit sedan i januari. 42 procent har en positiv uppfattning, 54 procent en negativ uppfattning. Störst är stödet bland vita över 50 år. Om nu Trumps radikala reformer skulle slå fel – och det i stället blivit högre priser, krympande industri, urholkad supermaktstatus, bakslag i domstolarna – måste Vance städa upp.</p>
<p>Misslyckas han lär rivalerna vittra blod.</p>
<div class="author-byline">Karin Henriksson är journalist och författare baserad i Washington D.C.
</div>
</div>
