Är Georgien nästa mål för Putin?

<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-163684"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="163684" data-pty="SW5sw6RzdCBhcnRpa2VsIChTYW1ow6RsbGUp" data-pna="w4RyIEdlb3JnaWVuIG7DpHN0YSBtw6VsIGbDtnIgUHV0aW4/" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2UvaW5sYXN0YXRleHRlci8xMS0yOS1hci1nZW9yZ2llbi1uYXN0YS1tYWwtZm9yLXB1dGluXy5tcDM=" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvMTEtMjktYXItZ2VvcmdpZW4tbmFzdGEtbWFsLWZvci1wdXRpbl8ubXAz">  <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/per-ekman/">Per&nbsp;Ekman</a> | 30 januari 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-georgien-nasta-mal-for-putin%2F&amp;t=%C3%84r+Georgien+n%C3%A4sta+m%C3%A5l+f%C3%B6r+Putin%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+Georgien+n%C3%A4sta+m%C3%A5l+f%C3%B6r+Putin%3F+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Far-georgien-nasta-mal-for-putin%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-georgien-nasta-mal-for-putin%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Är Georgien nästa mål för Putin?&body=https://kvartal.se/artiklar/ar-georgien-nasta-mal-for-putin/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/163684/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-georgien-nasta-mal-for-putin%2F&amp;t=%C3%84r+Georgien+n%C3%A4sta+m%C3%A5l+f%C3%B6r+Putin%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+Georgien+n%C3%A4sta+m%C3%A5l+f%C3%B6r+Putin%3F+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Far-georgien-nasta-mal-for-putin%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-georgien-nasta-mal-for-putin%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Är Georgien nästa mål för Putin?&body=https://kvartal.se/artiklar/ar-georgien-nasta-mal-for-putin/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/163684/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/ar-georgien-nasta-mal-for-putin/?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 12 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/5f9da7b3-6a4e-4a03-af8a-63a291ea103c"    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-163684">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "163684"></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 ">Året är 2004. Georgien, en liten före detta sovjetrepublik med Turkiet och Ryssland som närmaste grannar beskrivs som ett hopp för demokratin. Under Rosenrevolutionen året innan hade den valfuskande presidenten <strong>Eduard Sjevardnadze</strong> tvingats bort från makten. De nyvalda georgiska ledarna reser i skytteltrafik till Washington och Bryssel. Georgiens unge president <strong>Micheil Saakasjvili</strong> rapporteras ha en direktlina till USA:s president <strong>George W Bush</strong>, och vägen mot EU och Nato verkar ligga öppen.</p>
</div>
<div class="rest-of-article ">
<p>20 år senare stiftar georgiska regeringspartiet Georgisk dröm (GD) auktoritära lagar inspirerade av Kreml och anklagar utan bevis Väst för att försöka dra in landet i krig mot Ryssland, trots befolkningens fortsatta stöd för EU- och Natomedlemskap. Hur hamnade Georgien här?</p>
<p>Efter Rosenrevolutionen startas en intensiv reformperiod för att råda bot på den avskydda korruptionen i landet. Exempelvis sparkas 30 000 personer ur den notoriskt korrupta poliskåren över en natt.<sup>1</sup> Reformerna ger effekt, korruptionen minskar, vilket uppskattas av många men inte av alla. Som en dåvarande minister uttrycker det till mig på ett café i huvudstaden Tbilisi: ”Jag fick fiender, till och med inom min egen släkt.”<sup>2</sup></p>
<p>Internationella ledare som reser till landet fångas av den nyvalda georgiska regeringens energi och entusiasm. År 2005 besöker Bush som första amerikanska president Georgien och kallar landet för en frihetens fyrbåk i en annars turbulent region. Varje myndighetsbyggnad i Tbilisi pyntas med EU-flaggor och avenyn som leder till flygplatsen namnges efter president <strong>Bush</strong>.</p>
<h2>En alltmer irriterad Vladimir Putin</h2>
<p>Rysslands president <strong>Vladimir Putin</strong> noterar också utvecklingen i det södra grannlandet. Han gillar inte vad han ser. Särskilt ogillar han den självsäkra Saakasjvili, som utbildat sig i USA och som pratar flytande engelska och franska. Putin letar efter georgiska svagheter. Saakasjvilis huvudmål är, som han ofta uttrycker det, att återförena Georgien som på 1990-talet varit nära statskollaps efter flera krig i samband med Sovjetunionens sammanbrott. Utbrytarregionerna Sydossetien och Abchazien bröt sig då de facto loss från Georgien med rysk hjälp. Saakasjvili lyckas 2004 återta kontrollen över en tredje region, Adzjarien i västra Georgien, men misslyckas med de två övriga.</p>
<p>Här hittar Putin den svaghet han sökt efter. Under ett hemligt möte utanför Moskva 2006 ställer sig Putin upp och skäller ut USA:s utrikesminister <strong>Condoleezza Rice</strong> och kräver att USA ska sluta stödja Georgien. Han varnar också för att krig snart kan bryta ut.<sup>3</sup></p>
<blockquote><p>Kriget kunde ha blivit en väckarklocka i Väst, men konflikten glöms snabbt bort.</p></blockquote>
<p>Georgiens negativa erfarenhet av Ryssland på 1990-talet gör att man tidigt anar vad som kan komma att hända. Saakasjvili satsar stora summor på att rusta upp militären och försöker tillsammans med sin kollega president <strong>Viktor Jusjtjenko</strong> i Ukraina övertyga västländer om Natomedlemskap. USA:s Bush är för, liksom Storbritannien och flera nya Natoländer i Östeuropa som av egen erfarenhet vet vad Ryssland är kapabelt till. Länder som Tyskland, Italien och Frankrike är emot – en Natomedlemskapsprocess skulle enligt deras synsätt provocera Ryssland, skada ländernas ekonomiska relationer med Moskva och inte gynna alliansens säkerhet.</p>
<p>Dessutom är Ukraina splittrat i frågan, och Georgien har inte kontroll över sitt territorium. Efter bristande diplomatiska förberedelser utmynnar situationen i en intensiv debatt på Natotoppmötet i Bukarest i april 2008. Tonläget är högt och flera östeuropeiska ledare kritiserar Tyskland för eftergiftspolitik och jämför situationen med Storbritanniens politik mot Nazityskland 1938. Jämförelsen faller inte väl ut hos den dåvarande tyske utrikesministern <strong>Frank-Walter Steinmeier</strong>. Kompromissen på mötet utmynnar i ett gemensamt uttalande där Nato enas om att Georgien och Ukraina i framtiden kommer att bli medlemmar i organisationen.<sup>4</sup></p>
<p>Ingen tidsplan eller detaljer hur det ska gå till presenteras. Många menar i efterhand att detta var det sämsta möjliga alternativet. De två länderna saknar Natos säkerhetsgarantier, men Putin vet att det nu bara är en tidsfråga innan länderna kan vara bortom rysk kontroll om inget görs.</p>
<p>”Vi var vansinniga efter Bukarestmötet”, berättar en georgisk minister senare för mig, ”Vi varnade för vad Ryssland är kapabelt till, men tyvärr fick vi inget gehör”.<sup>5</sup></p>
<h2>Kriget som borde ha fått Väst att vakna</h2>
<p>Det ryska svaret kommer redan i augusti 2008. Efter en längre period av spänningar och skottväxlingar rasar plötsligt ett krig i Europa med Georgien på ena sidan och Sydossetien och Ryssland på den andra. Ryssland avancerar långt in på georgiskt territorium och vinner det fem dagar korta kriget. USA och EU stöttar Georgien politiskt och kritiserar Ryssland, men militärt står det lilla landet relativt ensamt. Bakom kulisserna får även Saakasjvilis administration kritik från ledare i USA och flera EU-länder för att ha agerat oförsiktigt gentemot utbrytarrepublikerna trots många varningar.<sup>6</sup> Ryssland drar sig tillbaka militärt från stora delar av georgiskt territorium men tar fullständig militär kontroll över Sydossetien och Abchazien samt erkänner utbrytarrepublikernas självständighet, på tvärs mot övriga internationella samfundet.</p>
<p>Kriget kunde ha blivit en väckarklocka i Väst, men konflikten glöms snabbt bort. USA initierar redan 2009 en ”omstart” med Ryssland under president <strong>Barack Obama</strong>. Tyskland är i full färd med att bygga gasledningen Nord Stream, som stärker den ekonomiska länken och beroendet till Moskva. Saakasjvili sitter trots ryska protester kvar som president men är sig inte lik efter kriget. Dessutom kritiseras han och hans parti UNM alltmer av många georgier för att driva en auktoritär politik.</p>
<p>Oppositionen är dock svag och splittrad, utan vare sig kraft eller resurser att utmana presidenten.</p>
<h2>Georgiens rikaste oligark träder in på scenen</h2>
<p>Över en natt förändras allt. 2011 träder plötsligt <strong>Bidzina Ivanisjvili</strong> – Georgiens överlägset rikaste man – in på den politiska scenen och grundar partiet Georgisk dröm (GD) med det uttalade målet att avsätta Saakasjvili. Många georgier är trötta på Saakasjvili, och GD vinner valet 2012 efter löften om en bättre ekonomi, en fortsatt provästlig utrikespolitik men även förbättrade relationer med Ryssland.</p>
<p>Ivanisjvili växer upp i en fattig familj på georgisk landsbygd men hamnar på 1990-talet i Moskva där han tjänar en stor förmögenhet.<sup>7</sup> I Moskva blir han nära vän med en grupp mycket inflytelserika ryska oligarker kallade <em>Semibankirschina</em> (sju bankirer) som bland annat hjälper till att säkra president <strong>Boris Jeltsins</strong> återval 1996. Moskva präglas vid den här tiden av organiserad brottslighet, och experter menar att det i stort sett är omöjligt att bli rik i staden utan kontakter med rysk säkerhetstjänst. Härifrån kommer den förvisso icke-belagda misstanken, som ofta presenteras av georgisk opposition, att rysk säkerhetstjänst fortfarande har inflytande över och kontrollerar Ivanisjvili.</p>
<figure id="attachment_163921" aria-describedby="caption-attachment-163921" style="width: 1024px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="wp-image-163921 size-full" src="https://kvartal.se/wp-content/uploads/2025/01/sdlaEmH2b9dfIM-nl.jpg" alt="kvartal" width="1024" height="683" data-wp-pid="163921" srcset="https://kvartal.se/wp-content/uploads/2025/01/sdlaEmH2b9dfIM-nl.jpg 1024w, https://kvartal.se/wp-content/uploads/2025/01/sdlaEmH2b9dfIM-nl-300x200.jpg 300w, https://kvartal.se/wp-content/uploads/2025/01/sdlaEmH2b9dfIM-nl-768x512.jpg 768w, https://kvartal.se/wp-content/uploads/2025/01/sdlaEmH2b9dfIM-nl-600x400.jpg 600w" sizes="(max-width: 1024px) 100vw, 1024px" /><figcaption id="caption-attachment-163921" class="wp-caption-text">Protester i Tbilisi, december 2024. Foto: Zurab Tsertsvadze/TT</figcaption></figure>
<p>Ivanisjvili flyttar tillbaka till Georgien och bosätter sig i ett 50-dollarmiljoners futuristiskt stål- och glashus på ett berg som överblickar Tbilisis historiska kvarter. Helikopterplattan, hajakvarier, zebror och modern konst gör att många jämför honom med en Bondskurk. Kritiker menar dock att jämförelsen haltar och riskerar att trivialisera Ivanisjvilis kapacitet och förståelse av makt. Kanske präglas han av sina ryska erfarenheter. De som träffat honom uppger att han är en maktspelare som skyddar sin familj och tidigt i sin politiska karriär fått uppfattningen att USA och EU inte respekterar honom, att de vill komma åt hans förmögenhet och få bort honom från makten. Ivanisjvili saknar förståelse för Väst. Visserligen har han bott en kort tid i Frankrike, men var då redan väldigt rik och träffade aldrig vanliga människor.</p>
<p>Som premiärminister uppmuntras han att åka på statsbesök till USA för att stärka kontakterna i Washington, men han förstår inte syftet, berättar en person som arbetat för honom.</p>
<p>Premiärminister Ivanisjvili avgår 2013 efter endast ett år på posten och utser en ung tidigare rådgivare som sin efterträdare. Det råder dock aldrig någon tvekan om vem som egentligen styr bakom kulisserna <span style="font-weight: 400;">–</span> ”mannen på berget” viskar georgiska experter när man frågar vem som bestämmer. Premiärministrarna kommer och går, men Ivanisjvili förblir kvar. Under GD:s första år vid makten samarbetar partiet dock med västvänliga partier och skriver 2014 under omfattande handels- och associationsavtal med EU. Några år senare får georgier visumfrihet för att turista i EU.</p>
<p>Glädjen bland befolkningen att äntligen ses som ett europeiskt land är enorm.</p>
<h2>Gradvis nedmontering av demokratin</h2>
<p>Georgien har aldrig haft starka demokratiska institutioner och GD manövrerar snart ut samarbetspartierna. Det viktigaste oppositionspartiet UNM är försvagat. Dess ledare Saakasjvili gör politisk karriär i Ukraina innan han på ett spektakulärt sätt återvänder till Georgien 2021, grips av polis och sätts i fängelse dömd för maktmissbruk under presidenttiden. Fler och fler georgier och internationella experter höjer nu ett varningens finger för GD.<sup>8</sup></p>
<p>Regeringspartiet vinner valet 2020 som slutar i turbulens när oppositionen inte accepterar valresultatet och anklagar GD för valfusk. Internationella valobservatörer pekar på brister i valutförandet, men i relativt milda ordalag. Det politiska dödläget löses genom förhandlingar ledda av EU där parterna enas om bland annat reformer av valsystemet, en överenskommelse som GD dock snart drar sig ur. I efterhand kan man se att partiet steg för steg gått i en alltmer auktoritär riktning, men att det skett så långsamt att många inte har reagerat. Dessutom upprepar GD regelbundet att man är för EU-medlemskap, vilket mildrar kritiken.</p>
<p>Rysslands storskaliga invasion av Ukraina 24 februari 2022 chockar en hel värld och även Georgien. Kriget påverkar landets politik på flera sätt. Vanliga georgier går man ur huse för att protestera mot Ryssland. Ukrainska flaggor pryder gatorna på ett aldrig tidigare skådat sätt, och husväggar i Tbilisi fylls med Natosymboler och Putinkritiska budskap. Rysslands attack väcker känslor och påminner georgierna om krigen med rysk inblandning på 1990-talet och femdagarskriget 2008. Georgiska regeringen ägnar sig samtidigt åt ett dubbelspel i den högre skolan.</p>
<p>Efter Rysslands attack följer GD Ukraina och Moldavien och ansöker om medlemskap i EU i mars 2022 – befolkningen jublar. Samtidigt börjar GD:s företrädare tala om ”det globala krigspartiet”, en konspiration som går ut på att ledande krafter i Väst tillsammans med den georgiska oppositionen försöker tvinga Georgien att öppna en andra front i kriget mot Ryssland.<sup>9</sup> Strategin är att skrämma befolkningen med att krig väntar om GD förlorar makten. Ukraina kallar hem sin Georgienambassadör. GD:s representanter gör ytterligare anmärkningsvärda uttalanden. På ett Natotoppmöte i Bratislava 2023 kallar georgiska premiärministern <strong>Irakli Garibasjvili</strong> Rysslands krig mot Ukraina katastrofalt, men fastslår samtidigt att en huvudanledning till kriget är Natos utvidgning.<sup>10</sup></p>
<p>GD anklagar även USA för att med bistånd stötta krafter som vill göra revolution i Georgien.</p>
<h2>Valet i oktober 2024</h2>
<p>Inför valet i oktober 2024 antar GD flera kontroversiella lagar. Mest känd är agentlagen, som med rysk förlaga syftar till att försvåra för det georgiska civilsamhället. Lagen drivs igenom trots massiva protester på gatorna. En skattelag antas som experter menar ska skydda Ivanisjvilis tillgångar i händelse av sanktioner från Väst. För att skydda ”georgiska värden” antas en lag mot landets redan utsatta hbtq-rörelse, en lag kraftigt påhejad av den populära georgisk-ortodoxa kyrkan.<sup>11</sup></p>
<p>GD talar öppet om att förbjuda oppositionen efter valet på grund av dess samröre med ”det globala krigspartiet”.<sup>12</sup> Inga bevis presenteras. GD hyllas av ryska företrädare och hittar en allierad i EU i den kritiserade ungerske premiärministern <strong>Viktor Orbán</strong>. EU, som gett Georgien kandidatstatus i december 2023 – ett första steg mot medlemskap – pausar integrationen på grund av GD:s agerande.</p>
<blockquote><p>Georgien balanserar nu på en knivsegg mellan att i framtiden bli en del av EU, Nato och Väst eller att gå i en mer auktoritär riktning där samarbetspartnerna heter Ryssland, Turkiet, Kina och Iran.</p></blockquote>
<p>Valet i oktober resulterar i en seger för GD med 54 procent mot den samlade oppositionens 38 procent. Anklagelser om allvarligt valfusk kommer från både internationella och georgiska valövervakare. Georgier jag pratar med är chockade över graden av valfusk.  Både den georgiska oppositionen och president <strong>Salomé Zurabisjvili</strong>, vars roll främst är ceremoniell men som nu axlar den oppositionella ledartröjan, kallar valet för stulet och oppositionen intar inte platserna i parlamentet.<sup>13</sup> Det redan spända läget trappas upp den 28 november när Georgiens premiärminister <strong>Irakli Kobakhidze</strong> meddelar att GD inte kommer att arbeta för medlemskapsförhandlingar med EU förrän tidigast 2028. Enligt mätningar är ungefär 80 procent av den georgiska befolkningen för EU-medlemskap, och många uppfattar Kobakhidzes besked som att GD givit upp drömmen om EU.<sup>14</sup></p>
<p>Storskaliga protester bryter ut mot regeringens beslut, och kravallpolis svarar med tårgas och vattenkanoner. Oppositionsledare arresteras och demonstranter misshandlas och grips.<sup>15</sup></p>
<p>I december 2024 väljs den regeringslojala <strong>Micheil Kavelasjvili</strong> till ny georgisk president i ett val som görs av GD:s representanter och inte av befolkningen. President Zurabisjvili, oppositionspartierna och proteströrelsen förklarar valet illegitimt och demonstrationerna fortsätter. I samband med det georgiska presidentvalet inför USA sanktioner mot Ivanisjvili och den dåvarande utrikesministern <strong>Antony Blinken</strong> kritiserar den georgiske ledaren för att bedriva en auktoritär och prorysk politik.<sup>16</sup></p>
<h2>Georgiens vägskäl, Europa eller Eurasien?</h2>
<p>Georgien balanserar nu på en knivsegg mellan att i framtiden bli en del av EU, Nato och Väst, eller att gå i en mer auktoritär riktning där samarbetspartnerna heter Ryssland, Turkiet, Kina och Iran. Den senare vägen går emot en majoritet av den georgiska befolkningens vilja, men frågan är om de har kraft nog att själva påverka landets öde?</p>
<p>Även för Ivanisjvili och hans närmaste krets står mycket på spel. Vad vill mångmiljardären uppnå? Det enkla svaret är att han vill bevara sin position som Georgiens rikaste och mest inflytelserika man. Sannolikt ser han och hans närmaste att en maktförlust i bästa fall kan resultera i landsflykt, i sämsta fall kan det innebära en förlust av förmögenheter och kanske även långa fängelsestraff. En annan drivkraft kan vara att Ivanisjvili med sin ryska bakgrund helt enkelt bedömer Väst som svagt och splittrat och att Ryssland och dess allierade kommer att vinna kriget i Ukraina. För ett litet grannland till Ryssland gäller det, enligt detta tankesätt, att satsa på rätt häst i det stormaktspel som präglar hela regionen.</p>
<p>Ytterligare en fråga som infinner sig är vad USA <span style="font-weight: 400;">– </span>med <strong>Donald Trump</strong> som president <span style="font-weight: 400;">– </span>och EU är beredda att göra för att stötta befolkningen i ett litet land i Europas utkant som sedan sent 1990-tal drömt om att vara en del av Väst? Detta i en tid där kriser och krig avlöser varandra. Kan Georgien undvika att återigen inordnas under rysk kontroll, ett öde landet historiskt redan mött under hundratals år?</p>
<p>Vad som är säkert är att Georgien med sin rika och långa historia står inför ett av sina viktigaste vägskäl på mycket länge. <a href="#_ednref1" name="_edn1"></a></p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="163684">  <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>Engvall, J. 2012. <em>Against the grain: how Georgia fought corruption and what it means</em>. Central Asia-Caucasus Institute &amp; Silk Road Studies Program, Stockholm.</li>
<li>Författarens intervju med tidigare georgisk minister, februari 2017.</li>
<li>Burns, W.J. 2020. <em>The Back Channel. a memoir of American diplomacy and the case for its renewal.</em> s. 201. Random House, New York.</li>
<li>Roxburgh, A. 2021. <em>The Strongman. Vladimir Putin and the Struggle for Russia</em>. Kapitel 10. I.B. Tauris, London.</li>
<li>Författarens intervju med tidigare georgisk minister, mars 2019.</li>
<li>Roxburgh, A. 2021. <em>The Strongman. Vladimir Putin and the Struggle for Russia</em>. Kapitel 10 &amp; 11. I.B. Tauris, London.</li>
<li>Gente, R. 2013. ”Bidzina Ivanishvili, a man who plays according to Russian rules?”. <em>Caucasus Survey </em>Vol.1, No.1, Oktober 2013, ss. 117-126.</li>
<li>Se exempelvis Fix, L. och Kapp, C. 2023. ”The Dangers of Democratic Backsliding in Georgia” Council on Foreign Relations. <a href="https://www.cfr.org/article/dangers-democratic-backsliding-georgia">https://www.cfr.org/article/dangers-democratic-backsliding-georgia</a></li>
<li>OC Media. 30 april 2024. ”Ivanishvili touts conspiracy theories at massive pro-government rally in Tbilisi”. https://oc-media.org/ivanishvili-touts-conspiracy-theories-at-massive-pro-government-rally-in-tbilisi/</li>
<li>Civil Georgia. 30 maj 2023. PM: NATO Enlargement ”One of the Main Reasons for Ukraine War”. https://civil.ge/archives/545397</li>
<li>Goedemans, M. 21 augusti 2024. ”What Georgia’s Foreign Agent Law Means for Its Democracy. Council on Foreign Relations”. https://www.cfr.org/in-brief/what-georgias-foreign-agent-law-means-its-democracy</li>
<li>Gavin, G. 23 augusti 2024. ”Georgia goes ’North Korea’ with bombshell plan to ban main opposition parties”. <em>Politico</em>. https://www.politico.eu/article/georgia-opposition-ban-georgian-dream-party-election-eu-enlargement-irakli-kobakhidze/</li>
<li>Gonzalez, J.C. 28 oktober 2024. ”Georgia&#8217;s president says election ’has been stolen’”. <em>Deutsche Welle</em>. https://www.dw.com/en/georgia-election-stolen-president-says-eu-russia/a-70621642</li>
<li>National Democratic Institute. 11 december 2023. NDI POLL: Georgian citizens remain committed to EU membership. https://www.ndi.org/publications/ndi-poll-georgian-citizens-remain-committed-eu-membership-nation-united-its-dreams-and</li>
<li>Voice of America. 4 december 2024. ”Police in Georgia arrest opposition leader as mass protests continue”. https://www.voanews.com/a/police-in-georgia-arrest-opposition-leader-as-mass-protests-continue/7886990.html</li>
<li>Blinken, A.J. 27 december 2024. ”Sanctioning Georgian Dream Founder Bidzina Ivanishvili”. https://www.state.gov/sanctioning-georgian-dream-founder-bidzina-ivanishvili/</li>
</ol>
</div>
</div>
<div class="author-byline">Per Ekman är doktor i statsvetenskap verksam vid Center for Statecraft and Strategic Communication, Handelshögskolan i Stockholm. Han disputerade 2024 på en avhandling om georgisk och ukrainsk utrikespolitik vid Uppsala universitet.
</div>
</div>
