800 år sedan slaget där Ryssland förlorades

<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-96314"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="96314" data-pty="SW5sw6RzdCBhcnRpa2VsIChTYW1ow6RsbGUp" data-pna="ODAwIMOlciBzZWRhbiBzbGFnZXQgZMOkciBSeXNzbGFuZCBmw7ZybG9yYWRlcw==" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2UvaW5sYXN0YXRleHRlci84MDBfYXJfc2VkYW5fc2xhZ2V0X2Rhcl9yeXNzbGFuZF9mb3Jsb3JhZGVzLm1wMw==" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvODAwLWFyLXNlZGFuLXNsYWdldC1kYXItcnlzc2xhbmQtZm9ybG9yYWRlcy5tcDM=">  <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: "><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%2F800-ar-sedan-slaget-dar-ryssland-forlorades%2F&amp;t=800+%C3%A5r+sedan+slaget+d%C3%A4r+Ryssland+f%C3%B6rlorades"    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=800+%C3%A5r+sedan+slaget+d%C3%A4r+Ryssland+f%C3%B6rlorades+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2F800-ar-sedan-slaget-dar-ryssland-forlorades%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%2F800-ar-sedan-slaget-dar-ryssland-forlorades%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=800 år sedan slaget där Ryssland förlorades&body=https://kvartal.se/artiklar/800-ar-sedan-slaget-dar-ryssland-forlorades/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/96314/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="author-section ">  <div class="author-section-inner">    <div class="author-image-holder"><div class="author-image" style="background-image: url('https://kvartal.se/wp-content/uploads/2024/07/Henrik_lowres2.jpg');"></div><img class="author-print-img" src="https://kvartal.se/wp-content/uploads/2024/07/Henrik_lowres2.jpg" style="display: none;">    </div>    <div class="by-disclaimer-holder" style="color: #8a3a67">Av <a href="https://kvartal.se/medverkande/henrik-hojer/">Henrik&nbsp;Höjer</a> | 31 maj 2023<div class="author-desc">Henrik Höjer är Kvartals vetenskapsredaktör. Han är även historiker och författare.
</div>    </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%2F800-ar-sedan-slaget-dar-ryssland-forlorades%2F&amp;t=800+%C3%A5r+sedan+slaget+d%C3%A4r+Ryssland+f%C3%B6rlorades"    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=800+%C3%A5r+sedan+slaget+d%C3%A4r+Ryssland+f%C3%B6rlorades+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2F800-ar-sedan-slaget-dar-ryssland-forlorades%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%2F800-ar-sedan-slaget-dar-ryssland-forlorades%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=800 år sedan slaget där Ryssland förlorades&body=https://kvartal.se/artiklar/800-ar-sedan-slaget-dar-ryssland-forlorades/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/96314/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/800-ar-sedan-slaget-dar-ryssland-forlorades/?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 11 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/96314"    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-96314">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "96314"></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 ">Den 31 maj 1223 rasade ett våldsamt slag i vad som idag är sydöstra Ukraina. Ett slag vars utgång påverkade mycket av hur Rysslands historia kom att gestalta sig. Resultatet av denna kraftmätning medförde att Ryssland fjärmades från den europeiska utvecklingen.</p>
</div>
<div class="rest-of-article ">
<p>Men låt oss backa exakt 800 år i tiden. Platsen är den ukrainska stäppen vid floden Kalka norr om Azovska sjön. Floden rinner ut vid Mariupol och striden stod en tre-fyra svenska mil norr om denna stad, troligen ungefär där det lilla samhället Donske ligger idag – som i nuläget hålls av ryska trupper. <a href="https://liveuamap.com/en">Hårda strider</a> rasar bara några tiotal kilometer därifrån.</p>
<blockquote><p>Enheten leddes av Djingis khans mest erfarna general, Subotai, som då var i 45-årsåldern.</p></blockquote>
<p>Slaget för 800 år sedan är detaljerat beskrivet i boken <em>Kalka river 1223. Genghiz khan’s mongols invade Russia</em> (Osprey publishing 2001) av <strong>David Nicolle</strong> och <strong>Viacheslav Shpakovsky</strong>. Våren 1223 hade en mongolisk ryttararmé etablerat sig på Krim och på stäpperna norr om Svarta havet. De hade anlänt söderifrån året innan via Kaukasus berg.</p>
<p><a href="http://faculty.washington.edu/dwaugh/rus/texts/MF1914.pdf">Novgorodkrönikan</a> berättar (i min översättning): ”På grund av våra synder anlände samma år okända stammar. Ingen visste vilka de var, varifrån de kom, vilket språk de talade, vilken folkgrupp de tillhörde eller vilken tro de hade, men de kallade sig tatarer. (…) Vi hade hört att de hade erövrat många länder och slaktat många gudlösa folk.”<sup>1</sup></p>
<h2>Ryttare från österlandet</h2>
<p>Armékåren hade året innan underkuvat det Georgiska kungariket. Enheten leddes av <strong>Djingis khans</strong> mest erfarna general, <strong>Subotai</strong>, som då var i 45-årsåldern. Han ledde två kavalleriregementen på 10 000 ryttare vardera. Det var i alla fall den nominella styrkan. Subotais gärningar är analyserade av historikern <strong>Richard A. Gabriel</strong> i boken <em>Genghis khan’s greatest general. Subotai the valiant</em> (University of Oklahoma press 2006).</p>
<p>På den andra sidan stod en konfederation av slaviska furstar och deras hjälptrupper. De hade till en början inte en aning om vilka inkräktarna var och varifrån de kom. De hade heller ingen uppfattning om vilket hot de stod inför. Inledningsvis hade man trott, eller hoppats, att de okända ryttarna var kristna. De tre vise männen hade ju kommit österifrån, och hade inte aposteln <strong>Tomas tvivlaren</strong> missionerat i Indien? Och vissa mongoliska <a href="https://en.wikipedia.org/wiki/Keraites">stammar</a> var faktiskt kristna. Men när mongolerna angrep det kristna Georgien 1221 svalnade förhoppningarna.<sup>2</sup></p>
<p>Bakgrunden till Subotais ankomst till stäpperna norr om Svarta havet kände de ryska furstarna förstås inte till. Ett par decennier tidigare hade Djingis khan lyckats ena alla nomadstammar som levde mellan Kina och Sibirien. Strax därpå angreps norra Kina. Sedan följde ett mongoliskt blixtkrig mot västra Centralasien på 1210-talet, där rikena föll i snabb takt.</p>
<p>År 1221 skickade Djingis khan Subotai västerut med en mindre armékår för att rekognoscera.</p>
<figure id="attachment_96318" aria-describedby="caption-attachment-96318" style="width: 1522px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="wp-image-96318 size-full" src="https://kvartal.se/wp-content/uploads/2023/05/Mongolkarta.png" alt="kvartal" width="1522" height="975" data-wp-pid="96318" srcset="https://kvartal.se/wp-content/uploads/2023/05/Mongolkarta.png 1522w, https://kvartal.se/wp-content/uploads/2023/05/Mongolkarta-600x384.png 600w, https://kvartal.se/wp-content/uploads/2023/05/Mongolkarta-300x192.png 300w, https://kvartal.se/wp-content/uploads/2023/05/Mongolkarta-768x492.png 768w" sizes="(max-width: 1522px) 100vw, 1522px" /><figcaption id="caption-attachment-96318" class="wp-caption-text">De mongoliska fälttågen på 1210- och 20-talen. Källa: Wikipedia.</figcaption></figure>
<p>Subotai och hans män red via Persien söder om Kaspiska havet, genom Kaukasus. Planen var att runda Kaspiska havet och återvända till Centralasien den vägen. Subotai besegrade flera motståndare och plundrade sig fram – och nådde dagens Ukraina och Ryssland, som då var ett lapptäcke av oberoende furstendömen. Och stäppen norr om Kaspiska havet och Svarta havet dominerades av nomadiska turkiska stammar, så kallade kumaner.</p>
<h2>Vinter vid Krim</h2>
<p>När Subotais styrka passerat Kaukasus berg 1222 möttes de av en kumansk armé – som mongolerna omedelbart besegrade. Vintern 1222/23 tillbringades norr om Krim, och de hann med att inta den genuesiska handelsstationen i Sudak på Krims sydkust i början av 1223. Subotai hade nämligen tidigare stött på venetianska köpmän vid Azovska sjön och ingått ett avtal om handelsförbindelser med dem (det är alltså ingen slump att <em>venetianaren</em> <strong>Marco Polo</strong> skulle besöka mongolriket ett halvsekel senare).</p>
<p>Kumanerna var nu varse hotet, och bad ryska furstar om hjälp. De beslöt att gå samman med kumanerna och mota de okända ryttarna i grind. I mars 1223 planerade furstarna av bland andra Kiev och Kursk fälttåget. I slutet av april samlas koalitionen av ryssar och kumaner ungefär fem mil nedström längs med Dnepr, en bit söder om Kiev.</p>
<p>Dit anlände nu mongoliska sändebud som försäkrade att de inte ville ha någon konflikt. De ville bara åt kumanerna, som de stridit mot året innan. Sannolikt var detta ett försök att splittra den rysk-kumanska alliansen. Vi vet även i efterhand att Subotai hade räknat med att hans stridströtta trupper som ridit tusentals kilometer skulle få förstärkningar från den mongoliska huvudstyrkan i västra Asien, men att dessa inte skulle anlända. Han försökte då förhandla sig ur det hotfulla läget, eftersom han inte kunde bedöma fiendens styrka.</p>
<p>Men ryssarna hedrade överenskommelsen med kumanerna. De hedrade dock inte de mongoliska sändebuden. Ryssarna anklagade dem för att vara spioner, och de dömdes till döden och avrättades. En kortsiktig vinst – men en långsiktig felbedömning av episka mått. I den mongoliska traditionen var sändebud fredade. Ett brott mot denna ordning <em>måste</em> straffas. Krig var nu oundvikligt.</p>
<blockquote><p>Subotai, som varit med och erövrat stora delar av Asien och aldrig förlorat en strid, gjorde sina män redo.</p></blockquote>
<p>Under april månad rörde sig den rysk-kumanska koalitionen nedströms längs med Dneprs västra stränder. I slutet av april anlände en ny mongolisk delegation och förklarade officiellt krig. Sändebuden fick denna gång återvända helskinnade.</p>
<p>Vissa uppgifter talar om att den rysk-kumanska armén var på 90 000 man, men detta är troligen överdrivet. Men det var en manstark koalition, och vid de första skärmytslingarna avrättades tillfångatagna mongoler, vars utrustning inte imponerade på ryssarna. De stötte på flera mindre grupper av mongoler, som alltid vek undan. Ryssarna, fulla av självförtroende, korsade Dnepr på en pontonbro och fortsatte österut över stäppen. Även där stötte de på mindre mongoliska avdelningar som flydde österut inför åsynen av den mäktiga hären. De fortsatte i den allt varmare våren. Mongolerna vek undan i över en veckas tid där de två arméerna hade nära kontakt med varandra.</p>
<p>Vid ett tillfälle blev en större mongolisk eftertrupp upphunnen och massakrerad.</p>
<h2>Blixtanfall</h2>
<p>Subotai, som varit med och erövrat stora delar av Asien och aldrig förlorat en strid, gjorde sina män redo. Han hade lett ett tjugotal fälttåg och stridit i över 60 slag. Enligt vissa uppgifter hade han förlorat ett öga i en av dessa strider. Han valde med omsorg platsen för den avgörande drabbningen. Ryssarna blev otåliga och övermodiga i vårhettan – vissa enheter rörde sig snabbare österut, andra var mer försiktiga. Bristen på samordning skulle snart visa sig fatal. När de första styrkorna nådde den lilla floden Kalka och var på väg att korsa den på morgonen den 31 maj satte Subotai in sitt motdrag – en överraskningsattack.</p>
<p>De mongoliska ryttarna anföll med pil och båge, sedan med blanka vapen. Flera av de ryska furstarna sårades eller dödades redan i slagets initiala skede, vilket gjorde att deras trupper kom i oordning. Snart kollapsade hela den rysk-kumanska koalitionen inför de stridsvana och disciplinerade mongolerna. Kaos utbröt.</p>
<p>Grupper av kumaner stal hästar och vapen av sina forna allierade när armén upplöstes och alla flydde i panik över stäppen. Mongolerna dödade merparten av de flyende som de lätt hann upp på sina snabba och starka hästar – jag har själv ridit på mongoliska hästar i Mongoliet och kan intyga att de är oerhört uthålliga.</p>
<figure id="attachment_96323" aria-describedby="caption-attachment-96323" style="width: 1024px" class="wp-caption alignnone"><img decoding="async" class="wp-image-96323 size-full" src="https://kvartal.se/wp-content/uploads/2023/05/sdlqKHvdJL_3hA-nl.jpg" alt="kvartal" width="1024" height="707" data-wp-pid="96323" srcset="https://kvartal.se/wp-content/uploads/2023/05/sdlqKHvdJL_3hA-nl.jpg 1024w, https://kvartal.se/wp-content/uploads/2023/05/sdlqKHvdJL_3hA-nl-600x414.jpg 600w, https://kvartal.se/wp-content/uploads/2023/05/sdlqKHvdJL_3hA-nl-300x207.jpg 300w, https://kvartal.se/wp-content/uploads/2023/05/sdlqKHvdJL_3hA-nl-768x530.jpg 768w" sizes="(max-width: 1024px) 100vw, 1024px" /><figcaption id="caption-attachment-96323" class="wp-caption-text">Staty av Djingis khan i dagens Mongoliet. Den är 40 meter hög och uppfördes år 2008. Foto: TT Nyhetsbyrån.</figcaption></figure>
<p>Enligt <a href="http://faculty.washington.edu/dwaugh/rus/texts/MF1914.pdf">Novgorodkrönikan</a> återkom bara var tionde man från fälttåget, som väl måste beskrivas som en katastrof för ryssarna. När påvens sändebud <strong>Plano Carpini </strong>passerade området norr om Svarta havet på 1240-talet vittnade han om oräkneliga mänskliga skelett och dödskallar som låg kringströdda på stäppen.</p>
<p>Furst <strong>Mstislav Romanovich III</strong> av Kiev och hans följe tillfångatogs i slagets slutskede. Mongolerna beslöt straffa honom och andra tillfångatagna furstar och ädlingar som hämnd för de avrättade sändebuden. De band furstarna och lade dem under ett trägolv där Subotai och hans närmsta män intog en festmåltid för att fira segern. Fångarna kvävdes sakta till döds under segrarnas tyngd.</p>
<p>Sedan vände den segerrika hären österut. De gick över Volga sommaren 1223 och red söderut mot trakterna av Samarkand där de anslöt sig till Djingis khan och rapporterade om de bördiga stäpperna i dagens Ukraina.</p>
<h2>Återkomsten på 1240-talet</h2>
<p>Subotai skulle dock återvända nästan 15 år senare, i spetsen för en långt större här. Denna gång angreps de ryska furstendömena österifrån, och även denna gång var Subotai framgångsrik. Han lyckades med det som <strong>Napoleon Bonaparte</strong> och <strong>Adolf Hitler</strong> längre fram i historien skulle misslyckas med – att erövra det landområde som sedan skulle bli Ryssland.</p>
<p>Slaget vid Kalka den 31 maj 1223 var bara den första aningen om den mongoliska militära övermakten. Eftersom flera furstar dödats och de ryska arméerna hade förintats 1223 kunde mongolerna nu operera med fruktan som vapen. När Subotai dök upp med en här i slutet av 1230-talet föll de ryska furstendömena ett efter ett. I december 1240 föll Kiev. Sedan anfölls det mäktiga ungerska riket som vid denna tid täckte stora delar av Centraleuropa. Även Ungern kollapsade sedan dess riddararméer utplånats av mongolerna.</p>
<blockquote><p>Det mongoliska arvet präglade området som skulle bli Ryssland under ett kvarts millennium.</p></blockquote>
<p>Även Polen och Balkan invaderades 1241 av mongoliska ryttarkårer som vann varje sammandrabbning med de europeiska riddarna. Mongoliska styrkor siktades utanför Wien i början av 1242. Sedan vände de tvärt, och lämnade Centraleuropa – men inte Ryssland. Orsaken var att deras härskare, Djingis khans son, <strong>Ogodai</strong>, hade avlidit hemma i Mongoliet. Detta innebar att alla fälttåg måste avbrytas. Europa kunde andas ut.</p>
<figure id="attachment_96342" aria-describedby="caption-attachment-96342" style="width: 1686px" class="wp-caption alignnone"><img decoding="async" class="wp-image-96342 size-full" src="https://kvartal.se/wp-content/uploads/2023/05/Mongoliska-.png" alt="kvartal mongoler" width="1686" height="883" data-wp-pid="96342" srcset="https://kvartal.se/wp-content/uploads/2023/05/Mongoliska-.png 1686w, https://kvartal.se/wp-content/uploads/2023/05/Mongoliska--1536x804.png 1536w, https://kvartal.se/wp-content/uploads/2023/05/Mongoliska--600x314.png 600w, https://kvartal.se/wp-content/uploads/2023/05/Mongoliska--300x157.png 300w, https://kvartal.se/wp-content/uploads/2023/05/Mongoliska--768x402.png 768w" sizes="(max-width: 1686px) 100vw, 1686px" /><figcaption id="caption-attachment-96342" class="wp-caption-text">Statyer av mongoliska krigare på stäppen i dagens Mongoliet. Foto: Henrik Höjer</figcaption></figure>
<p>Det som skulle bli Ryssland hamnade sedan under mongoliskt välde i flera hundra år – den så kallade Gyllene horden. Historiker har konstaterat att detta arv påverkat Rysslands auktoritära traditioner. ”Skrapa på ryssen, så kommer tataren fram”, ska Napoleon Bonaparte ha sagt.</p>
<p>Historieprofessorn <strong>Klas-Göran Karlsson</strong>, som är specialiserad på rysk historia vid Lunds universitet, fastslår att det mongoliska arvet präglade området som skulle bli Ryssland under ett kvarts millennium.</p>
<p>– Det som skulle bli Ryssland vände sig med mongolerna uppenbart bort från Europa och Östersjöområdet, som ju var den självklara kontaktytan under Kievrikets tid, med Kiev och Novgorod som östliga Hansastäder, konstaterar han. Därmed gick det blivande Ryssland miste om sådant som i grunden omgestaltade väst, som renässansen och reformationen. Den teknisk-vetenskapliga revolutionen och upplysningen blev bara smala stråk. Livegenskapen befästes. Tsarerna kallade sig länge vid högtidliga tillfällen för khaner, <strong>Ivan I</strong> var khanens skattmas (”<em>Ivan kalita</em>, Ivan med pengapungen”), och särskilt idag finns väl anledning att notera betydelsen av detta maktpolitiska arv, den asiatiska despotin.</p>
<h2>Kopplingar till nutiden</h2>
<p>Idag, 800 år senare, rasar alltså blodiga strider på ungefär samma plats som denna fatala första kraftmätning mellan ryssar och mongoler.</p>
<p>Dagens ryske försvarsminister, general <strong>Sergei Shoigu</strong>, har dock en märklig koppling till denna historia. En av Shoigus föräldrar kommer från den ryska delrepubliken Tuva, som ligger nära den mongoliska gränsen, och <a href="https://en.wikipedia.org/wiki/Sergei_Shoigu">Shoigu är alltså halvtuvan</a>. Tuvaner talar en turkisk dialekt och är besläktade med mongolerna. Shoigus centralasiatiska bakgrund och utseende har lett till att han i ryska media ibland har framställts som en <a href="https://www.washingtonexaminer.com/policy/foreign/russian-criticism-ukraine-war-conduct-military-chief">ny Subotai</a>. I alla fall <a href="https://meduza.io/en/feature/2022/09/15/they-re-mostly-after-loans">före</a> kriget – som han leder på ett sätt som trots allt har föga likheter Subotais.</p>
<figure id="attachment_96320" aria-describedby="caption-attachment-96320" style="width: 1024px" class="wp-caption alignnone"><img decoding="async" class="wp-image-96320 size-full" src="https://kvartal.se/wp-content/uploads/2023/05/sdlMOQyeCXEEh4-nl.jpg" alt="kvartal" width="1024" height="683" data-wp-pid="96320" srcset="https://kvartal.se/wp-content/uploads/2023/05/sdlMOQyeCXEEh4-nl.jpg 1024w, https://kvartal.se/wp-content/uploads/2023/05/sdlMOQyeCXEEh4-nl-600x400.jpg 600w, https://kvartal.se/wp-content/uploads/2023/05/sdlMOQyeCXEEh4-nl-300x200.jpg 300w, https://kvartal.se/wp-content/uploads/2023/05/sdlMOQyeCXEEh4-nl-768x512.jpg 768w" sizes="(max-width: 1024px) 100vw, 1024px" /><figcaption id="caption-attachment-96320" class="wp-caption-text">En ny Subotai? Rysslands försvarsminister general Sergei Shoigu. Foto: TT Nyhetsbyrån.</figcaption></figure>
<p>Den verklige Subotai levde tills han var en bit över 70 år gammal. Påvens sändebud Plano Carpini mötte honom i slutet av 1240-talet i mongolväldets huvudstad Karakorum i dagens Mongoliet.</p>
<p>Subotai är en av militärhistoriens främsta ledare. Hans treåriga kavalleriraid har kallats en av de ”mest fantastiska i krigshistorien”. Det talas till och med om att begreppet blixtkrig kommer från honom – en taktik som byggde på rörelse, överraskning och att slå in djupa kilar in i motståndarens territorium. Fälttågen mot Svartahavsregionen på 1220-talet och mot hela Öst- och Centraleuropa på 1230- och 40-talen praktiserades på just detta sätt.</p>
<blockquote><p>Ett av de första moderna militärhistoriska verken om mongolisk krigföring publicerades på ryska.</p></blockquote>
<p>Enligt historikern Richard A. Gabriel lärde sig nazityskarna detta koncept av sovjetiska generaler. Efter Rapallofördraget 1922 mellan Sovjetunionen och Tyskland (som var det första landet i Europa att erkänna Sovjetunionen) tränades tyska trupper på sovjetisk mark. Tyska officerare fick då kontakter inom den nya Röda armén, där ryska officerare sedan länge hade haft kunskaper om hur de rörliga nomadstammarna i Centralasien bedrev krig. Ett av de första moderna militärhistoriska verken om mongolisk krigföring publicerades på ryska av general <strong>Mikhail I. Ivanin</strong> vid mitten av 1800-talet.<sup>3</sup></p>
<p>Fältmarskalk <strong>Mikhail Tukhachevsky</strong>, som byggde upp Röda armén efter revolutionen, tog utifrån bland annat denna studie fram de doktriner som byggde på den mongoliska erfarenheten – att slå hårt och djupt, att vara extremt rörlig, att alltid behålla initiativet och själv bestämma platsen för strid.</p>
<figure id="attachment_96321" aria-describedby="caption-attachment-96321" style="width: 731px" class="wp-caption alignnone"><img decoding="async" class="wp-image-96321 size-full" src="https://kvartal.se/wp-content/uploads/2023/05/sdl5kr7AJYg908-nl.jpg" alt="" width="731" height="1024" data-wp-pid="96321" srcset="https://kvartal.se/wp-content/uploads/2023/05/sdl5kr7AJYg908-nl.jpg 731w, https://kvartal.se/wp-content/uploads/2023/05/sdl5kr7AJYg908-nl-600x840.jpg 600w, https://kvartal.se/wp-content/uploads/2023/05/sdl5kr7AJYg908-nl-214x300.jpg 214w" sizes="(max-width: 731px) 100vw, 731px" /><figcaption id="caption-attachment-96321" class="wp-caption-text">Fältmarskalk Mikhail Tukhachevsky, som försökte införa Subotais principer i Röda armén. Foto från 1930-talet. Foto: TT Nyhetsbyrån</figcaption></figure>
<p>Men historien tog en märklig vändning. Tukhachevsky– och hundratals andra höga officerare – rensades ut under <strong>Stalins</strong> terror. Den 44-årige Tukhachevsky greps och torterades på försommaren 1937 och erkände att han var en tysk agent – hans bevarade <a href="https://en.wikipedia.org/wiki/Mikhail_Tukhachevsky#/media/File:May_25_1937_Tukhachevsky_recognition.jpg">bekännelse</a> är till och med blodfläckig – varpå han dömdes till döden och sköts i nacken (även hans fru och bröder avrättades).</p>
<p>Och det blev Nazityskland, som snappat upp hans taktiska doktriner, som fick visa världen hur ett modernt blixtkrig kan bedrivas.</p>
<p>Så lever minnet av Subotai än idag, 800 år efter en av hans otaliga segrar – som bidrog till att skapa dagens Ryssland.</p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="96314">  <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>Begreppet ”tatarer” användes ofta i Europa om mongoler under medeltiden, inte sällan stavades det ”tartarer”. Idag avser ordet tatarer mongolättlingar i framför allt västra Asien och östra Europa.</li>
<li>Jackson, Peter: <em>The mongols and the west, 1221–1410</em>, kap 6.</li>
<li>Gabriel, Richaed A.: <em>Genghis khan’s greatest general, Subotai the valiant</em>, kap 7.</li>
</ol>
</div>
</div>
<div class="author-byline">Henrik Höjer är Kvartals vetenskapsredaktör. Han är även historiker och författare.
</div>
</div>
