Varför ge Ryssland en större roll än det förtjänar?

<div class="kv-article-audio-player">  <div class="kv-aap-listen">    <div class="kv-listen-left">      <span>        <i class="fas fa-headphones-alt"></i>      </span>    </div>    <div class="kv-aap-listen-right">Lyssna på texten    </div>  </div><div id    = "kv-pod-holder-167846"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-tis="825" data-tin="1036" data-pid="167846" data-pty="SW5sw6RzdCBhcnRpa2VsIChTYW1ow6RsbGUp" data-pna="VmFyZsO2ciBnZSBSeXNzbGFuZCBlbiBzdMO2cnJlIHJvbGwgw6RuIGRldCBmw7ZydGrDpG5hcj8=" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2UvaW5sYXN0YXRleHRlci82LTMwLXZhcmZvci1nZS1yeXNzbGFuZC1lbi1zdG9ycmUtcm9sbC1hbi1kZXQtZm9ydGphbmFyXy5tcDM=" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvNi0zMC12YXJmb3ItZ2Utcnlzc2xhbmQtZW4tc3RvcnJlLXJvbGwtYW4tZGV0LWZvcnRqYW5hcl8ubXAz">  <div class="kv-pod-holder-inner">    Laddar <span class="blink-me">...</span>  </div></div>  <div class="kv-listen-subscribe">    <span>Följ Kvartals poddar:</span>    <a target="_blank" href="https://podcasts.apple.com/se/podcast/kvartal/id1447122576?mt=2">Apple</a>    |     <a target="_blank" href="https://open.spotify.com/show/6NsieE1iFLypikr3slKII0?si=ppaUJpA3R-mo8L9L4XgudA">Spotify</a>  </div></div><div class="kvartal-meta clearfix" style="color: ">Av <a href="https://kvartal.se/medverkande/mark-brolin/">Mark&nbsp;Brolin</a> | 24 februari 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%2Fvarfor-ge-ryssland-en-storre-roll-an-det-fortjanar%2F&amp;t=Varf%C3%B6r+ge+Ryssland+en+st%C3%B6rre+roll+%C3%A4n+det+f%C3%B6rtj%C3%A4nar%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=Varf%C3%B6r+ge+Ryssland+en+st%C3%B6rre+roll+%C3%A4n+det+f%C3%B6rtj%C3%A4nar%3F+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fvarfor-ge-ryssland-en-storre-roll-an-det-fortjanar%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%2Fvarfor-ge-ryssland-en-storre-roll-an-det-fortjanar%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Varför ge Ryssland en större roll än det förtjänar?&body=https://kvartal.se/artiklar/varfor-ge-ryssland-en-storre-roll-an-det-fortjanar/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/167846/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%2Fvarfor-ge-ryssland-en-storre-roll-an-det-fortjanar%2F&amp;t=Varf%C3%B6r+ge+Ryssland+en+st%C3%B6rre+roll+%C3%A4n+det+f%C3%B6rtj%C3%A4nar%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=Varf%C3%B6r+ge+Ryssland+en+st%C3%B6rre+roll+%C3%A4n+det+f%C3%B6rtj%C3%A4nar%3F+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fvarfor-ge-ryssland-en-storre-roll-an-det-fortjanar%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%2Fvarfor-ge-ryssland-en-storre-roll-an-det-fortjanar%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Varför ge Ryssland en större roll än det förtjänar?&body=https://kvartal.se/artiklar/varfor-ge-ryssland-en-storre-roll-an-det-fortjanar/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/167846/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 class="listen" href="https://kvartal.se/artiklar/varfor-ge-ryssland-en-storre-roll-an-det-fortjanar/?inlast=1">  <i class="fas fa-headphones-alt"></i>  <span>Inlästa texter</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/3ca987f1-15dd-4cd6-8daa-9fea74c5dfc5"    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-167846">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "167846"></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 "><strong>Donald Trump</strong> har byggt sin politiska karriär på att bryta mot konventioner, riva upp gamla dogmer och utmana etablissemanget. Strategin bidrog till den mest förbluffande politiska comebacken i amerikansk politisk historia.</p>
</div>
<div class="rest-of-article ">
<p>Men nu när Trump i förhållande till Ryssland följer ett förlegat manuskript förbluffar han, genom sin platta och daterade förståelse för Rysslands roll i världen.</p>
<p>Visst har det ofta hetat att <strong>Vladimir Putin</strong> är en strategisk mästare, en myt som despoter har lättare att upprätthålla eftersom de aldrig behöver förklara sig. I själva verket påminner Putins skruvade anspråk på Ukraina, genom sina kopplingar till påstådda historiska oförrätter, mer om 1800-talet än om en genomtänkt strategi för 2000-talet.</p>
<h2>Ryssland är ingen supermakt</h2>
<p>Trots Putins stora ambitioner har den ryska krigsmakten haft uppenbart svårt att ens erövra östra Ukraina. Vid det här laget har Ryssland förbrukat så mycket krut – i både bokstavlig och bildlig mening – att nödåtgärder är nödvändiga för att bibehålla det militära trycket.</p>
<p>Det senare är inte lätt med en kraftigt blödande kleptokratekonomi. Landet har förlorat sin förut största handelspartner (Europa), oljeprodukter måste slumpas ut till andra köpare, sanktionerna går bara delvis att kringgå, inflation och räntor är skyhöga, rubelvärdet har fallit som en sten och med hundratusentals ryssar i arbetsför ålder döda eller skadade har även arbetskraftsutbudet påverkats. Många vittnar om att moralen i armén är usel.</p>
<p>Ryssland är dessutom en ekonomisk dvärg vid sidan av Europa som helhet. I slutändan avgör alltid den ekonomiska kapaciteten den militära kapaciteten. Redan före kriget var landets bnp på nivå med Italiens och lägre än Nordens och Polens kombinerade bnp. Tillförlitlig data existerar inte just nu eftersom Ryssland slutat släppa information om nyckeltal. Det är knappast ett styrketecken. Visserligen brukar en krigsekonomi leda till tillfälligt uppumpad tillväxt, sedan följer i regel en kraftig baksmälla.</p>
<p>Ukrainainvasionen har utvecklats till en katastrof för Ryssland, och utan kontrollen över propagandapparaten hade Putin, utan tvekan, redan varit ett minne blott. Att Ryssland ändå fortfarande framställs som en stormakt är en kvarleva från det förflutna. I själva verket är landet knappt ens längre en regional stormakt.</p>
<p>Varför fortsätter då Ryssland att framställas som ett existentiellt hot?</p>
<p>Rysslands styrka överdrivs inte bara av Kreml utan även av dess motståndare. Såväl amerikanska som europeiska militär- och säkerhetsintressen driver narrativet – inte avsiktligt skevt, men eftersom uppdraget är att identifiera hot och friktionsytor. Här spelar även karriärincitament in; ingen sparkas för att ha varnat i onödan, men att undervärdera ett hot som sedan realiseras kan vara synonymt med karriärdöd.</p>
<blockquote><p>Putin står och faller med att Väst fortsätter att överskatta Rysslands kapacitet.</p></blockquote>
<p>Politiska och ekonomiska särintressen har varit än mer avgörande. Berlin och Bryssel gjorde Europa beroende av rysk gas, trots åratals varningar från Polen och Ukraina. Att lita på sin historiska ärkefiende för energiförsörjning var en så fundamental geopolitisk groda att den lär bli ett skolboksexempel på när kortsiktiga kommersiella särintressen tillåtits överskugga långsiktiga säkerhetspolitiska prioriteringar.</p>
<p>Fast inte än. Många ansvariga sitter fortfarande vid makten och kastar grus i försöken till hederlig analys. Inte minst i Tyskland, där starka intressen fortsatt bedriver eftergiftspolitik mot Moskva. Bara genom att överdriva Rysslandshotet kan det framställas som en klok realpolitisk nödvändighet att bygga starka band till Putin.</p>
<h2>Putin beroende av sina fienders missbedömningar</h2>
<p>Kärnvapenhotet används ibland för att förstärka narrativet, men Putin vet att om han faktiskt låter kärnvapen brisera så skulle det leda till omedelbara och kraftfulla motåtgärder från kärnvapennationerna USA, Storbritannien och Frankrike. Putin kan då inte räkna med många minuter kvar vid makten. Så kärnvapenhotet har ett visst ryskt värde som hot – men inget värde alls som realiserad politik.</p>
<p>Putin står och faller med att Väst fortsätter att överskatta Rysslands kapacitet. Hade Europa insett svagheten och agerat mer resolut hade Putin sannolikt aldrig vågat invadera Ukraina.</p>
<p>Om Ukraina tillåtits använda västerländska vapen mot mål i Ryssland hade situationen sett annorlunda ut. I stället stoppas Ukraina med argumentet att det skulle ”eskalera konflikten” – trots att både Ryssland och Ukraina maxar sin kapacitet. Tal om ”eskaleringsrisk” blir då snarast hånfullt.</p>
<p>Även i realtid spökar Västs förlegade övertro på Putins och Rysslands styrka. Som en direkt följd har Trump gått in i förhandlingarna genom att redan från start ge bort centrala kort. I andefattig kontrast till samme Trump, som på andra håll skiftat förhandlingslägen genom att vägra acceptera snarare än validera daterade föreställningar.</p>
<h2>Fredspriset som hägrar?</h2>
<p>Vad är det då som driver Trump? Den viktigaste faktorn är nog att Trump matats med underrättelserapporter som fortfarande övervärderar Rysslands styrka. Om man ser Moskva som en stormakt blir det logiskt att, som Trump och försvarsministern <strong>Pete Hegseth</strong> tycks göra, dra just slutsatsen att Ukraina och Europa måste acceptera fullbordat faktum.</p>
<p>Att Kina numera är USA:s verkliga rival, inte Ryssland, stärker Trumps argument att Europa i alla händelser måste ta större ansvar för egen säkerhet. Ett rimligt krav – inte minst då det även är i Europas intresse att Taiwanfrågan inte exploderar.</p>
<p>Sedan har vi Trumps uttalade mål att gå till historien som en ”fredspresident”. En vällovlig ambition <span style="font-weight: 400;">– </span>men synnerligen problematisk om det leder till att även en svag despot som Putin belönas för sina aggressioner. Om Väst accepterar stöld av territorium genom våld, vad sänder det för signal till en betydligt mäktigare aktör som Kina? Trumps utspel är därför olyckligt inte bara för Ukraina och Europa utan även för USA – och Taiwan.</p>
<p>Kommersiella intressen, inklusive tillgången till Ukrainas strategiskt viktiga industrimineraler, spelar också in. Villkoret för fortsatt amerikansk inblandning i Ukraina är långtgående amerikansk affärsnärvaro. Att Trump hoppat i säng med Putin just nu handlar kanske inte minst om att mjuka upp team <strong>Zelenskyj</strong> inför den sortens förhandlingar.</p>
<p>Gammalt groll påverkar också. Europas ledare har i åratal använt Trump som slagpåse för att plocka inrikespolitiska poäng. År 2019 vägrade Zelenskyj att efterkomma Trumps begäran om att utreda <strong>Joe</strong> och <strong>Hunter Bidens</strong> affärer i Ukraina <span style="font-weight: 400;">– </span>en handling som, åtminstone i Trumps ögon, påverkade utgången av valet 2020. Den enda nyckelpolitiker i Europa som konsekvent agerat traditionellt diplomatiskt respektfullt gentemot Trump? Just det, Putin. Det bidrar nog också till att förklara varför Trump hellre tycks lyfta luren till Moskva än till Berlin, Bryssel, Paris eller Kiev <span style="font-weight: 400;">–</span> särskilt om han felaktigt betraktar Putin som Europas starkaste man och därmed mer jämbördig.</p>
<p>Kan även ett inslag av självsabotage finnas med i bilden? För ovanlighetens skull har Trump, sedan valsegern, hyllats mer än han attackerats. Kastar han nu ur sig lätt punkterade spontana absurditeter också för att återgå till vad kognitiva psykologer skulle kalla en familjär emotionell baslinje, inklusive i Trumps fall ständig konflikt? Spekulativt, ja <span style="font-weight: 400;">– </span>men Trump illustrerar, tydligt som få andra, hur individpsykologi också påverkar geopolitiken. Därmed är det nödvändigt att tänka bortom traditionella analysramar.</p>
<h2>Ljuspunkter i mörkret</h2>
<p>Ljuspunkter saknas ändå inte.</p>
<ul>
<li>Ryssland utgör ingen existentiell fara för Europa <span style="font-weight: 400;">–</span> förutom för randstater som Ukraina, Georgien och Moldavien. Att dessa länder utmanar Moskva är ett ryskt svaghetstecken. Så vi i Sverige kan sluta svettas, oavsett att många av intresseskäl kommer att fortsätta att hävda annorlunda.</li>
<li>Europa upprustar och Sverige är Natomedlem <span style="font-weight: 400;">– </span>även om så skett utifrån en överdriven hotbild. Ukrainakriget visar att även ett svagt Ryssland kan invadera länder utan avskräckande försvar eller försvarsgarantier. Att vara en enkel munsbit frestar i onödan.</li>
<li>Trump styr inte ensam förhandlingarna, och hans första stora utrikespolitiska misstag kan korrigeras. Redan pågår sådan justering <span style="font-weight: 400;">– </span>vicepresident <strong>JD Vance</strong> <a href="https://edition.cnn.com/2025/02/14/politics/jd-vance-us-troops-russia-ukraine-intl-hnk/index.html">hotar Ryssland med marktrupper</a>, och Storbritanniens <strong>Keir Starmer</strong> öppnar för <a href="https://www.thetimes.com/world/russia-ukraine-war/article/ukraine-war-latest-news-trump-us-russia-vgkv6w6zr">Ukrainas Natomedlemskap</a>, Sverige och Storbritannien pratar om att skicka fredsbevarande soldater, Vita huset tycks överväga <a href="https://www.telegraph.co.uk/world-news/2025/02/20/ukraine-russia-war-donald-trump-putin-zelensky-peace-kyiv/">omedelbart Natomedlemskap</a> om Ryssland angriper igen. I kongressen, som ännu inte blandat sig i, är stödet för Ukraina betydligt starkare än i Vita huset.</li>
<li>Oavsett överord är Nato inte i fara. USA har inte ”övergett” Europa utan prioriterar Kina, dagens viktigaste rival, medan Ryssland inte längre hotar Europa på allvar och definitivt inte USA. Vidare har det aldrig varit rimligt att tro att USA godmodigt skulle tackla de katastrofala följderna efter att Europas ledare nedrustat, gjort sig energiberoende av Ryssland, samt himlat med ögonen när Trump under sin första mandatperiod <a href="https://www.youtube.com/watch?v=Vpwkdmwui3k">varnade för faran</a>. Rimligare är nog att Europas Natoländer framöver bär huvudansvaret för att hålla den undervärderat ihåliga ryska regimen Ryssland i schack, medan USA förblir yttersta säkerhetsgarant om ett Natoland attackeras. Precis dit verkar vi vara på väg.</li>
</ul>
<p>Omedelbart önskvärt vore likväl att team Trump tar tydlig ställning för den angripna parten, demokratiska Ukraina, och mot angriparen, despotins Ryssland. Snarare än spelar med i det gamla, förlegade narrativet om Ryssland som okuvlig stormakt.</p>
<p>Sedan gammalt förväxlas ofta pessimism med realism. Det är farligt. Äkta realism tar höjd för hela bilden <span style="font-weight: 400;">– </span>inklusive fiendens svagheter. Eftersom ensidigt riskfokus kan leda till just självuppfyllande pessimistiska resultat. Helt i onödan. Som i realtid.</p>
<p>Västs oförmåga att erkänna Rysslands begränsningar har gjort att Kreml kunnat fortsätta spela ett stormaktsspel som borde ha varit förlorat för länge sedan. Det är hög tid att ändra på den saken.</p>
<div class="author-byline">Mark Brolin är geopolitisk strateg, nationalekonom och författare till bland annat boken ”Healing broken democracies. All you need to know about populism” (2021).
</div>
</div>
