I korthet
För 250 år sedan, den 19 augusti 1772, genomförde Gustav III (1746–1792), en oblodig statskupp i Stockholm. Kuppen avbröt Sveriges första experiment med parlamentarism, partiväsende och tryckfrihet. Det konstitutionella styret ersattes av ett personligt kungavälde.
<div class="kvartal-meta clearfix" style="color: ">Av <a href="https://kvartal.se/medverkande/erik-bodensten/">Erik&nbsp;Bodensten</a> | 12 maj 2022<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%2Fnar-ryssland-var-den-svenska-forfattningens-forsvarare%2F&amp;t=N%C3%A4r+Ryssland+var+den+svenska+f%C3%B6rfattningens+f%C3%B6rsvarare"    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=N%C3%A4r+Ryssland+var+den+svenska+f%C3%B6rfattningens+f%C3%B6rsvarare+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fnar-ryssland-var-den-svenska-forfattningens-forsvarare%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%2Fnar-ryssland-var-den-svenska-forfattningens-forsvarare%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=När Ryssland var den svenska författningens försvarare&body=https://kvartal.se/artiklar/nar-ryssland-var-den-svenska-forfattningens-forsvarare/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/67386/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a><a href   = "https://kvartal.se/skriv-ut/67386/pdf"    target = "_blank"    class  = "pr-link"    title  = "Ladda ner artikeln som PDF"><i class="fas fa-file-pdf 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="author-section author-section-external">  <div class="author-section-inner">    <div class="author-image-holder"><span class="icon-kvartal-hare"></span>    </div>    <div class="by-disclaimer-holder" style="color: #8a3a67">Eventuella åsikter och slutsatser i texten är skribentens egna.    </div>  </div></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%2Fnar-ryssland-var-den-svenska-forfattningens-forsvarare%2F&amp;t=N%C3%A4r+Ryssland+var+den+svenska+f%C3%B6rfattningens+f%C3%B6rsvarare"    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=N%C3%A4r+Ryssland+var+den+svenska+f%C3%B6rfattningens+f%C3%B6rsvarare+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fnar-ryssland-var-den-svenska-forfattningens-forsvarare%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%2Fnar-ryssland-var-den-svenska-forfattningens-forsvarare%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=När Ryssland var den svenska författningens försvarare&body=https://kvartal.se/artiklar/nar-ryssland-var-den-svenska-forfattningens-forsvarare/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/67386/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a><a href   = "https://kvartal.se/skriv-ut/67386/pdf"    target = "_blank"    class  = "pr-link"    title  = "Ladda ner artikeln som PDF"><i class="fas fa-file-pdf 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 5 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/67386"    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-67386">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "67386"></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 ">För 250 år sedan, den 19 augusti 1772, genomförde<strong> Gustav III</strong> (1746–1792), en oblodig statskupp i Stockholm. Kuppen avbröt Sveriges första experiment med parlamentarism, partiväsende och tryckfrihet. Det konstitutionella styret ersattes av ett personligt kungavälde.</p>
</div>
<div class="rest-of-article ">
<p>Vad som förorsakade det frihetstida ständerväldets fall har diskuterats. Konservativa och liberala historiker har värderat händelsen mycket olika. Klart är att styrelseskickets legitimitet hade undergrävts. Det kom alltmer att förknippas med korruption, inflation, en förråad politisk samtalston, politiserade rättsprocesser, partiegoism, utländskt inflytande och regeringsmaktens förfall.</p>
<h2>Rysslands motstånd avgörande</h2>
<p>Det fanns emellertid ett avgörande hinder för de som ville se en författningsrevision. Europas stormakter motsatte sig varje förändring. Deras intressen tillvaratogs bäst av status quo. Mest avgörande var Rysslands motstånd. Fruktan för en restaurerad stark kungamakt som åter kunde göra Sverige till ett militärt hot spelade här in. Likaså intresset att fortsatt kunna ha inflytande över Sverige. Den ryska statsledningen ville under inga villkor acceptera en stärkt svensk regeringsmakt.</p>
<p>Länge hade Ryssland intagit en självpåtagen roll som försvarare av den fria svenska författningen. År 1769 gick man ett steg längre, och slöt ett försvarsförbund tillsammans med Preussen och Danmark, där de senare förband sig att med militära maktmedel bistå Ryssland att upprätthålla det svenska styrelseskicket. Varje svensk författningsändring skulle betraktas som <em>casus foederis</em> och aktivera alliansen.</p>
<blockquote><p>I decennier hade den ryska statsledning ingripit i svensk politik.</p></blockquote>
<p>Gustav III:s statskupp har gått till historien som en mycket hastig affär. Då förbiser man emellertid att händelserna i augusti 1772 endast utgjorde kuppens första inrikes fas. För att krönas med framgång måste även den andra utrikes fasen lyckas. Den stora frågan var hur Ryssland skulle reagera.</p>
<p>I decennier hade den ryska statsledning ingripit i svensk politik. Man hade satsat enorma summor och etablerat djupgående samarbeten med svenska statstjänstemän och beslutsfattare. Allt detta höll nu på att gå om intet. De sedvanliga påverkansmetoderna – informationskampanjer, hot och vapenskrammel, partistöd och direkta mutor – förslog inte i detta läge. Den ryska statsledningen hade missbedömt situationen och blivit frånsprungen händelseutvecklingen.</p>
<p>Endast ett storskaligt anfall, företrädesvis tillsammans med Preussen och Danmark, kunde återställa ordningen.</p>
<p>Tidpunkten var emellertid sämsta tänkbara. Ryssland saknade nästan helt trupper längs den svenska gränsen i Finland. Ett frigörelseförsök inte olikt det svenska pågick sedan några år i Polen. Detta tog stora ryska resurser i anspråk. Motvilligt hade den ryska ledningen under kejsarinnan <strong>Katarina II</strong> kommit till slutsatsen att ryskt styre genom ombud inte längre fungerade. Polen måste krossas och infogas i det ryska imperiet och dess två mäktiga grannar, Preussen och Österrike, skulle endast acceptera detta om de själv fick ta del av bytet. Beslutet var redan fattat och i augusti 1772 skred man till verket och genomförde Polens första delning.</p>
<p>Sedan flera år var Ryssland dessutom inbegripit i ett blodigt krig med Osmanska riket om kontrollen av den norra Svarta havs-kusten. Kriget gick Rysslands väg men turkarna höll alltjämt ut.</p>
<h2>Angreppet på Sverige skjuts upp</h2>
<p>Mot denna bakgrund tvingades Ryssland uppskjuta anfallet på Sverige. Danmark protesterade mot detta traktatsbrott men kunde inte ensamt ingripa. Även Preussen var upptaget i Polen och önskade avvakta. Anfallet fick anstå tills nästa år.</p>
<p>Gustav III hade valt sitt tillfälle med omsorg. Avgörande var även hans beslut att invänta Frankrikes stöd. Sveriges traditionella allierade hade länge motsatt sig planerna på en statskupp. Likt de andra stormakterna såg man Sveriges fria författning som en förutsättning för sitt inflytande i Stockholm. I flera år hade dock en omprövning varit på väg. Skulle Sverige någonsin bli en allierad som Frankrike kunde ha nytta av måste regeringsmakten stärkas. Vid årsskiftet 1772 övergav Versailles definitivt alla planer på en legal svensk författningsrevision. Frankrike stod redo att helhjärtat stödja Gustavs planer på en statskupp. Stora summor ställdes till kungens förfogande, nödvändiga för att övertyga eventuellt klenmodiga svenska patrioter.</p>

<p>Vårvintern 1773 stod det klart att Ryssland gjorde sig redo för ett anfall. Stora styrkor drogs samman längs gränsen. I Versailles pågick samtidigt intensiva förhandlingar. I februari kunde Sverige säkra ett avtal om stora franska subsidier som skulle hjälpa till att finansiera en svensk upprustning. Samtidigt gjordes en fransk flotteskader redo att löpa ut. 12 000 franska soldater skulle överföras till Sydsverige för att möta ett danskt anfall.</p>
<blockquote><p>När allt kom omkring valde den ryska statsledningen att prioritera Rysslands expansion söderut.</p></blockquote>
<p>Tanken på en fransk flotta i Östersjön fick i sin tur Storbritannien att reagera. Den brittisk-franska relationen gick från dålig till fientlig. Kuppen i Stockholm hotade dra in Europa i ett storkrig. Frankrike tvingades backa. I gengäld var Storbritannien berett att bistå Frankrikes diplomatiska stöd till Sverige. Att låta Sverige gå Polens öde till mötes låg inte heller i brittiskt intresse. Rysslands dominans i östra Europa sågs redan som för stor.</p>
<p>Åter fick den ryska statsledningen konstatera att ett anfall på Sverige inte var möjligt. Rysslands polska förehavanden drog ut på tiden. Misstron mot Preussen var samtidigt grundmurad. Kriget mot Osmanska riket fortsatte och i Volga-området inleddes en folkresning som snart skulle sträcka sig till Uralbergen och ta år att slå ned.</p>
<p>De svenska försvarsåtgärderna och de franska subsidierna började också bära frukt. I Finland gjordes försvaret redo att slå tillbaka ett ryskt anfall. Långsamt klingade krigshotet av. Ryssland tvingades acceptera fait accompli.</p>
<h2>Ryssland valde vägen till Svarta havet istället</h2>
<p>Gustav III hade riskerat både sin krona och ett storkrig, och tagit hem spelet.</p>
<p>Stärkt av sin framgång blev Gustav gradvis alltmer benägen att försöka ta sig ur svåra situationer genom att, likt den där augustidagen 1772, sätta allt på spel. Till sist, sent om kvällen, den 16 mars 1792, övergav Fortuna honom. Efter att ha mottagit ett anonymt varningsbrev stegade kungen ner till den pågående maskeradbalen – där han mötte sitt öde.</p>
<p>När allt kom omkring valde den ryska statsledningen att prioritera Rysslands expansion söderut. Katarina ville skapa en stor rysk koloni i dagens Ukraina, <em>Novorossiya</em>. Denna imperiedröm fick företräde. År 1774 tvingades Osmanska riket sluta fred. Ryssland fick fotfäste vid Svarta havet. Krim blev ett ryskt protektorat. Men den ryska expansionen där skulle snart återupptas.</p>
<p>Det har gått 250 år sedan dessa händelser. Mycket har hunnit förändras under denna tid, men vissa långa historiska linjer framskymtar idag tydligare än på länge. Dit hör den ryska imperietraditionen, med dess koloniala blick på det vidsträckta område som Ryssland betraktar som sin intressesfär. Man påminns också om tidigare ryska svårigheter att styra genom ombud och på mer dolda sätt. Frånsprunget händelseutvecklingen har rysk statsledning också tidigare tvingats välja mellan krigshandlingar och att acceptera fullbordat faktum. Hur man valt har i hög grad avgjorts av tillgången på militära resurser.</p>
<p>För Sverige och Finland står ett möjlighetsfönster på glänt, nu som då.</p>
<div class="author-byline">Erik Bodensten är historiker verksam vid Lunds universitet.
</div>
</div>
