
<p class="has-drop-cap wp-block-paragraph">Det första Kriteriet kördes 1993 och vanns av Jan-Olov Perssons <strong>Järvsöfuxen</strong> (e. Auvin-Hallingjänta). 200.000 kronor var förstapriset då. Vinnaren idag får 500.000 kronor.<br>Kriteriestoet avgjordes för första gången 1999 då <strong>Buuas Jansi</strong> (e. Alm Svarten-Giklingstjerna) fick det i sammanhanget mycket blygsamma förstapriset 30.000 kronor.<br>Sedan ifjol är könen precis som på fyraåringssidan uppdelade och jämställda, så även i Kriteriestoet väntar en halv miljon kronor på vinnaren.</p>



<p class="wp-block-paragraph">Fredagens segerherre i Östersund med dubbla klassiska triumfer, Öystein Tjomsland, sitter med trumf på hand inför treåringarnas klassiker. Sju av 24 finalister kommer från norrmannens framgångsrika storstall.<br>Av fyra inkvalade till Kriteriet väljer Tjomsland <strong>Sjö Prinsen</strong> (e. Bork Odin), som i sin tävlingsdebut vann Kriteriekvalet på 1.28,6a/2.140 meter. I Kriteriestoet med tre finalister blev Tjomslands val <strong>Elita</strong> (e. Moe Odin), som debuterade i kvalet med en andraplats.</p>



<p class="wp-block-paragraph">Öystein Tjomsland brukar oftast utmanas av Jan-Olov Persson i unghästsammanhang på kallblodssidan, men nu ställs hans hingstar mot en häst tränad av Frode Hamre! <strong>Overvik Prinsen</strong> (e. Will Prinsen) har inlett tävlingskarriären på bästa sätt med fem segrar på lika många starter.<br>Frode Hamre må skörda de största framgångarna med varmblod, men på meritlistan finns framför allt seger i norska Derbyt med <strong>Ingbest</strong> (e. Dotterud Teddy) 2016 och Stoderbyt med <strong>Karmland Anna</strong> (e. Bork Odin) 2018.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/07/oysteintjomslandface-617x333.jpg" alt="" class="wp-image-474068"/><figcaption class="wp-element-caption">Öystein Tjomsland har sju hästar i finalerna av Kriteriet och Kriteriestoet. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<h2 class="wp-block-heading">Startlista Svenskt Kallblodskriterium</h2>



<p class="wp-block-paragraph"><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li>Sjö Prinsen (e. Bork Odin) – Öystein Tjomsland</li>



<li>Björli Bolt (e. Tekno Odin) – Tom Erik Solberg (Öystein Tjomsland)</li>



<li>Overvik Prinsen (e. Will Prinsen) – Vidar Hop (Frode Hamre)</li>



<li>Friska Viljan (e. Järvsö Björn) – Oskar Kylin Blom</li>



<li>Haslehaugens Loke (e. Tekno Odin) – Mats E Djuse (Jan-Olov Persson)</li>



<li>Eld Vide C.G. (e. Tekno Eld) – Per Linderoth (Jan-Olov Persson)</li>



<li>Vännfors Borken (e. Smedheim Solan) – Mats Gällerstedt</li>



<li>Skeie Balder (e. Tekno Odin) – Ulf Ohlsson (Öystein Tjomsland)</li>



<li>Bokli Leo (e. Galileo) – Geir Flåten</li>



<li>Re Alkapital (e. Pydin) – Henrik Svensson (Öystein Tjomsland)</li>



<li>Leopold (e. Galileo) – Lars Anvar Kolle (Geir Flåten)</li>



<li>Monster Mohikan (e. Lome Diamant) – Torbjörn Jansson (Oskar Kylin Blom)</li>
</ol>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/03/lannemsiljeheat2-617x333.jpg" alt="" class="wp-image-146361"/><figcaption class="wp-element-caption">Lannem SIlje och Tor Wollebaek. Foto Jeannie Karlsson/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Superstoet <strong>Lannem Silje</strong> (e. Åsajerven), 1.18,8ak*/6.881.134 nkr, är den klart snabbaste Kriteriesegraren hittills. Hon matchades mot de jämnåriga hingstarna istället för mot stona och sopade på 1.24,6a/2.140 banan med konkurrenterna. <strong>Ekeld</strong> (e. Lome Elden) är med de 1.25,1 han travade som tvåa bakom Lannem Silje den lika klart näst snabbaste hästen i Kallblodskriteriet…</p>



<p class="wp-block-paragraph">Snabbaste vinnare bland hingstar och valacker är svenskfödde <strong>Bäcklös Uriel</strong> (e. Smedheim Solan). Den av Nicklas Blom tränade treåringen vann tillsammans med Wiktor Kylin-Blom för tre år sedan på 1.25,6a/2.140 meter. Den tiden står sig fortsatt som svenskt rekord över medeldistans med autostart. Ifjol vann norskfödde <strong>Brolin</strong> (e. Lome Brage) på 1.26,3a.</p>



<p class="wp-block-paragraph"><strong>De fem snabbaste Kriteriesegrarna är:</strong></p>



<ul class="wp-block-list">
<li>2013 Lannem Silje (e. Åsajerven) – Tor Wollebaek, 1.24,6a/2.140</li>



<li>2019 Bäcklös Uriel (e. Smedheim Solan) – Wiktor Kylin-Blom, 1.25,6a</li>



<li>2018 Eld Rask (e. Tekno Odin) – Ulf Ohlsson, 1.25,7a</li>



<li>2014 Smedheim Solan (e. Bork Odin) – Kai Johansen, 1.25,8a</li>



<li>2021 Brenne Odin (e. Bork Odin) – Åsbjörn Tengsareid – 1.25,8a</li>
</ul>



<p class="has-text-align-center wp-block-paragraph">***</p>



<h2 class="wp-block-heading">Startlista Kriteriestoet</h2>



<p class="wp-block-paragraph"><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li>Troll Sterkfaksine (e. Tekno Odin) – Jan Roar Mjölneröd</li>



<li>Asakblomst (e. Tekno Odin) – Geir Flåten</li>



<li>Majblomster (e. Tekno Odin) – Mats E Djuse (Jan-Olov Persson)</li>



<li>Guli Stina (e. Briskeby Philip) – Henrik Svensson (Anders Wallin)</li>



<li>Voje Lotta (e. Ängsborken) – Lars Anvar Kolle (Jan Kristian Överdal)</li>



<li>Prinsessan Stöen (e. Bork Odin) – Marcus Lilius (Jan-Olov Persson)</li>



<li>Backeballerina (e. Tekno Odin) – Björn Karlsson</li>



<li>Fröken Oline (e. Tekno Odin) – Johan Kringeland Eriksen</li>



<li>Elita (e. Moe Odin) – Öystein Tjomsland</li>



<li>Garli Andrea (e. Bork Odin) – Tom Erik Solberg (Öystein Tjomsland)</li>



<li>Prinsesse Ness Tjo (e. Moe Odin) – Björn Steine (John Ragnvald Ness)</li>



<li>Sjö Kosa (e. Tekno Odin) – Ulf Ohlsson (Öystein Tjomsland)</li>
</ol>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">Från och med i fjol var hingstar/valacker och ston helt uppdelade i varsin klass med en halv miljon kronor till vinnaren. I Kriteriehistorien har tre ston besegrat hingstarna när de valt att gå ut i Svenskt Kallblodskriterium istället för Kriteriestoet. Förutom <strong>Lannem Silje</strong> är det även <strong>Söstra</strong> (e. Elding) och Arne Nilsen 1998 och <strong>Horgen Lotta</strong> (e. Järvsöfaks) och Geir Vegard Gundersen 2006.</p>



<p class="wp-block-paragraph">I Kriteriestoet är en svenskfödd häst snabbast: <strong>Guli Anna</strong> som vann tillsammans med Umåkertränaren Stefan Johansson för fyra år sedan på 1.26,7a/2.140 meter.</p>



<p class="wp-block-paragraph"><strong>Snabbaste vinnare i Kriteriestoet:</strong></p>



<ul class="wp-block-list">
<li>2019 Guli Anna (e. Bork Odin) – Stefan Johansson, 1.26,7a/2.140</li>



<li>2015 Aase (e. Åsajerven) – Öystein Tjomsland, 1.26,8a</li>



<li>2014 Brenne Rödi (e. Horgen Tore) – Jan Roar Mjölnerod, 1.27,0a</li>



<li>2022 Lannem Stella (e. Tekno Odin) – Mats E Djuse, 1.28,0a</li>



<li>2021 Dunungen (e. Smedheim Solan) – Örjan Kihlström – 1.28,7a</li>
</ul>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/08/brolin-617x333.jpg" alt="" class="wp-image-478673"/><figcaption class="wp-element-caption">Brolin. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Jan-Olov Persson har sedan premiärsegern med <strong>Järvsöfuxen</strong> vunnit Kallblodskriteriet fem gånger till som tränare och med sex tränarsegrar står han i särklass i Kriteriehistorien.</p>



<p class="wp-block-paragraph">Förra året var han den store segerherren när hans <strong>Brolin</strong> (e. Lome Brage) vann Kriteriet och <strong>Lannem Stella</strong> (e. Tekno Odin) vann Kriteriestoet.</p>



<p class="wp-block-paragraph"><strong>Tränare med två eller fler vinnare i Svenskt Kallblodskriterium:</strong></p>



<ul class="wp-block-list">
<li>Jan-Olov Persson – 6 – Järvsöfuxen 1993, Skaffer Brunen 2000, B.W.Modde 2012, Tekno Eld 2017, Eld Rask 2018, Brolin 2022</li>



<li>Ola Engevold – 2 – Rapp Rigel 1996, Wik Elden 2008</li>



<li>Jon A Högstad – 2 – Alm Rau Jo 2001, Frisli To Jo 2003</li>



<li>Jan Norberg – 2 – Troll Kevin 2002, Eld Kevin 2007</li>



<li>Öystein Tjomsland – 2 – Sjö Vinn 2016, Brenne Bas 2020</li>
</ul>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/07/oskarkylinblom-617x333.jpg" alt="" class="wp-image-101914"/><figcaption class="wp-element-caption">Oskar Kylin Blom. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Han har en andraplats i Svenskt Kallblodskriterium med <strong>Bäcklös Faron</strong> (e. Järvsö Tore) från 2020, då Tjomsland vann med <strong>Brenne Bas</strong> (e. Horgen Tore). Till idag har Gävletränaren Oskar Kylin Blom kvalat in två treåringar till Kriteriet.</p>



<p class="wp-block-paragraph">Det handlar om fartfyllda duon <strong>Friska Viljan</strong> (e. Järvsö Björn) och <strong>Monster Mohikan</strong> (e. Lome Diamant), som båda hade galoppinslag på vägen till finalplats.<br>Oskar är med och deläger båda hästarna och han kör Friska Viljan, som aldrig varit sämre än tvåa på fem starter. Torbjörn Jansson sitter upp bakom Monster Mohikan, som å sin sida redan plockat tre segrar.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">När det gäller kuskar så har Jan-Olov Persson lånat ut fyra av sina vinnare, vilket gör att han ”bara” har två kusksegrar själv. Istället är det Jomar Blekkan och Ulf Ohlsson som vunnit flest Kriterier, tre vardera.</p>



<p class="wp-block-paragraph"><strong>Kuskar med två eller fler vinnare:</strong></p>



<ul class="wp-block-list">
<li>Jomar Blekkan – 3 – Alm Rau Jo 2001, Frisli To Jo 2003, Slått Eld 2005</li>



<li>Ulf Ohlsson – 3 – Wik Elden 2008, Tekno Eld 2017, Eld Rask 2018</li>



<li>Jan Norberg – 2 – Troll Kevin 2002, Eld Kevin 2007</li>



<li>Jan-Olov Persson – 2 – Järvsöfuxen 1993, B.W.Modde 2012</li>



<li>Öystein Tjomsland – 2 – Sjö Vinn 2016, Brenne Bas 2020</li>



<li>Tor Wollebaek – 2 – Rapp Rigel 1996, Lannem Silje 2013</li>
</ul>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">Norske <strong>Elding</strong> är hingsten som förändrade kallblodssporten när han klev in i aveln. Genomslaget blev enormt och mängder av hans söner, sönsöner och döttrar tog vid efter matadoren. Kallblodstravarens utveckling tog nya steg när Eldings blod kom in med tidiga och snabba hästar. I svenskt Kallblodskriterium har hans avkommor förstås gjort stora avtryck.</p>



<p class="wp-block-paragraph">Själv är han pappa till fyra vinnare (se nedan). Han är farfar till sju vinnare (<strong>Lome Elden</strong> och <strong>Moe Odin</strong> har tre vinnare vardera och <strong>Horgen Tore</strong> en). Han är farfars far till fem vinnare (<strong>Tekno Odin</strong> och <strong>Lome Kongen</strong> två vinnare var och <strong>Lome Brage</strong> en) och farfars farfar till <strong>Bäcklös Uriel</strong> som har <strong>Smedheim Solan</strong> som pappa.</p>



<p class="wp-block-paragraph">19–11 är ställning i norsk favör när det gäller vinnarnas födelseland.</p>



<p class="wp-block-paragraph"><strong>Avelshingstar med två eller fler vinnare:</strong></p>



<ul class="wp-block-list">
<li>Elding – 4 – Lykke Gutten 1995, Söstra 1998, Eld Kevin 2007, Elling 2009</li>



<li>Moe Odin – 3 – Hågå Odin 2010, B.W.Modde 2012, Brenne Odin 2021</li>



<li>Järvsöfaks – 2 – Horgen Lotta 2006, Galileo 2015</li>



<li>Lome Kongen – 2 – Lome Felix 2011, Sjö Vinn 2016</li>



<li>Rigel Jo – 2 – Alm Rau Jo 2001, Frisli To Jo 2003</li>



<li>Tekno Odin – 2 – Tekno Eld 2017, Eld Rask 2018</li>



<li>Troll Jahn – 2 – Rolex K. 1997, Troll Kevin 2002</li>
</ul>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/03/teknoeldtestimg0014-617x333.jpg" alt="" class="wp-image-62834"/><figcaption class="wp-element-caption">Tekno Eld. Foto Mia Törnberg/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Det finns Kriterieexperter bland fölston som verkat på svensk mark. <strong>Farmesona</strong> (e. Barrison) är mamma till två vinnare av loppet: <strong>Troll Kevin</strong> (e. Troll Jahn) och <strong>Eld Kevin</strong> (e. Elding), som båda tränades och kördes av Jan Norberg.</p>



<p class="wp-block-paragraph">Samma fina facit kan norskfödda <strong>Eldsiri</strong> (e. Järvsöfaks) visa upp. Hon vann själv Kriteriestoet på Dannero tillsammans med Hans Petter Tholfsen i träning hos Jan-Olov Persson och följde upp med vinster i norska Stokriteriet, Oaks och Stoderbyt. I avelsboxen är hon mamma till Kriterievinnarna <strong>Tekno Eld</strong> (e. Tekno Odin) och <strong>Eld Rask</strong> (e. Tekno Odin), båda tränade av Jan-Olov Persson och körda av Ulf Ohlsson.<br>Tekno Elds äldsta avkommor som far är tre år i år och redan i första kullen har han en Kriteriefinalist i Jan-Olov Persson-tränade Eld Vide C.G.</p>



<p class="wp-block-paragraph">När det gäller debuthingstar har även döde <strong>Lome Diamant</strong> en Kriteriefinalist (<strong>Monster Mohikan</strong>), medan <strong>Ängsborken</strong> är pappa till snabbaste försöksvinnaren <strong>Voje Lotta</strong> i Kriteriestoet.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/08/envis-617x333.jpg" alt="" class="wp-image-478959"/><figcaption class="wp-element-caption">Jan-Olov Persson-tränade Envis och Mats E Djuse. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph"><strong>Lax Vilja</strong> (e. Moe Odin), 1.31,4ak/91.100 kr, gjorde inga stora avtryck på tävlingsbanan med en seger på 27 starter, men fick sin revansch i avelsboxen. Elva avkommor har hon fått och nio av dem är i startbar ålder. Samtliga har startat och alla utom en har dessutom vunnit lopp.<br>Pärlan i sammanhanget är – hittills är bäst att tillägga – stoet <strong>Uggla I Mossen</strong> (e. Järvsöfaks), 1.24,2m/1.932.686 kr, som var 2013-kullens drottning med dubbla Kriteriestosegrar och vinst i Biris Uppfödningslopp som treåring, samt seger i Stoderbyt i Norge som fyraåring i Jan-Olov Perssons regi.<br>Bland syskonen finns Robert Bergh-tränade miljonären <strong>Buska Blyg</strong> (1.175.000 kr), Jasmin Isings <strong>Crussi Dull</strong> (701.100 kr), <strong>Björli Odin</strong> (667.724 kr), <strong>Björli Mai</strong> (595.854 kr) och fredagens finalist i Svenskt Kallblodsderby <strong>Envis</strong> (510.694 kr).</p>



<p class="wp-block-paragraph">I eftermiddag är hon högaktuell igen, som mamma till Oskar Kylin Blom-tränade <strong>Friska Viljan</strong> (e. Järvsö Björn), som inlett tävlingskarriären med en seger och fyra andraplatser på fem starter. Han är snabbast av alla svenskfödda treåringar i voltstart i år, då han travade 1.28,5/2.160 meter i Gävle i juni. </p>



<p class="wp-block-paragraph"><strong>Noterbart om mödrarna i Kriteriet:</strong></p>



<ul class="wp-block-list">
<li>Björlikos (mor till Björli Bolt) var trea i Kriteriestoet på Dannero 2015</li>



<li>Eigelands Helga (Haslehaugens Loke) var tvåa i Stokriteriet i Norge 2016</li>



<li>Tangen Jerkila (Skeie Balder) vann både Stokriteriet och Oaks i Norge 2015</li>



<li>Tekno Lotta (Leopold) var trea i Stokriteriet och vann Oaks 2016</li>
</ul>



<p class="wp-block-paragraph"><strong>Noterbart om mödrarna i Kriteriestoet:</strong></p>



<ul class="wp-block-list">
<li>Börke Luna (mor till Asakblomst) var tvåa i Oaks i Norge 2010</li>



<li>Voje Spika (Voje Lotta) vann Oaks i Norge 2010 och är mamma till norske Derbytrean 2020 Voje Piril</li>



<li>Ness Tjo Stjerna (Prinsesse Ness Tjo) var tvåa i Stoderbyt i Norge 2015</li>



<li>Gunda (Sjökosa) är mor till Sjö Perla som var tvåa i både Derbystoet och Stoderbyt ifjol</li>
</ul>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/08/janolovpersson2-617x333.jpg" alt="" class="wp-image-478961"/><figcaption class="wp-element-caption">Jan-Olov Persson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Kriteriestoet har alltså några år kortare historia än Kriteriet, men dominanten bland tränarna är densamme. Jan-Olov Persson ståtar med sex tränarvinster sedan premiären 1999 och segrade förra året med <strong>Lannem Stella</strong> (e. Tekno Odin).<br>Notabelt är att bakom loppets 24 vinnare står hela 18 olika tränare.</p>



<p class="wp-block-paragraph"><strong>Tränare med två eller fler vinnare:</strong></p>



<ul class="wp-block-list">
<li>Jan-Olov Persson – 6 – Idenors Kessi 2000, Åkre Flamman 2001, Eldsiri 2009, Uggla I Mossen 2016, Dunungen 2021, Lannem Stella 2022</li>



<li>Öystein Tjomsland – 2 – Aase 2015, Voje Maren 2018</li>
</ul>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">2 svenskfödda hästar vann uttagningslopp till Kriteriestoet. <strong>Stjärnblomsters</strong> lillasyster <strong>Majblomster</strong> (e. Tekno Odin) ska försöka lyckas bättre än vad Stjärnblomster gjorde när hon också vann sitt försök 2017. I finalen slutade hon nämligen oplacerad, men tog fin revansch som fyraåring med seger i Derbystoet och andraplats i norska Stoderbyt.<br>Fast vad som komma skulle efter att hon blivit mamma som femåring kunde inte ens tränaren Jan-Olov Persson drömma om. Stjärnblomsters framgångar de tre senaste säsongerna har gjort henne till Sveriges vinstrikaste sto genom tiderna.<br>– Framför allt i Gävle var hon fantastisk bra och höll undan för duktige Friska Viljan (tvåa i Kriteriekval). Då gick hon 1.29,1 i voltstart, men även om hon är en riktigt bra sort tvivlar jag på att hon kan nedåt 1.26 som krävs för att vinna. Voje Lotta var enorm i kvalet, säger Jan-Olov Persson.</p>



<p class="wp-block-paragraph">Uppfödaren Fredrik Andersson kunde jubla åt seger för <strong>Guli Anna</strong> (e. Bork Odin) i Kriteriestoet för fyra år sedan i Stefan Johanssons träning. I år sätter Andersson hoppet till försöksvinnaren <strong>Guli Stina</strong> (e. Briskeby Philip), som tränas av Anders Wallin. Guli Stina är lillasyster till <strong>Guli Roy</strong> med 1,4 miljoner kronor inspunget.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">Ingen kusk har vunnit Kriteriestoet fler än två gånger. Bland de som lyckats med det finns Örjan Kihlström som två gånger om triumferat med en häst uppfödd på Menhammar Stuteri, ägd av Stall Segerhuva och tränad av Jan-Olov Persson. Senast skedde det 2021 med <strong>Dunungen</strong> (e. Smedheim Solan).</p>



<p class="wp-block-paragraph"><strong>Kuskar med två vinnare:</strong></p>



<ul class="wp-block-list">
<li>Örjan Kihlström – Uggla I Mossen 2016, Dunungen 2021</li>



<li>Lars Anvar Kolle – Finspika 2007, Voje Maren 2018</li>



<li>Jan-Olov Persson – Idenors Kessi 2000, Åkre Flamman 2001</li>
</ul>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2018/09/teknoodinkrnikanr38-617x329.jpg" alt="Tekno Odin och Ulf Ohlsson, Krönika nr 38" class="wp-image-30584"/><figcaption class="wp-element-caption">Tekno Odin och Ulf Ohlsson. Foto Jeannie Karlsson/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Norske <strong>Bork Odin</strong> har tagit över avelstronen bland hingstarna och i Kriteriestoet är han ensam om att ha lämnat tre vinnare som far. Han står bakom tre av de sex senaste vinnarna och i årets upplaga har han två döttrar till start i <strong>Prinsessan Stöen</strong> och <strong>Garli Andrea</strong>.</p>



<p class="wp-block-paragraph">Ifjol blev Tekno Odin pappa till sin första vinnare i Kriteriestoet när <strong>Lannem Stella</strong> segrade på Dannero. I årets finalfält dominerar han stort. Hela sex av tolv finalister har Tekno Odin som far!</p>



<p class="wp-block-paragraph">Fördelningen mellan Sverige och Norge när det gäller vinnarens födelseland är 14–10 i norsk favör.</p>



<p class="wp-block-paragraph"><strong>Avelshingstar med två eller fler vinnare:</strong></p>



<ul class="wp-block-list">
<li>Bork Odin – 3 – Myrs Hera 2017, Guli Anna 2019, Hopp Karoline 2020</li>



<li>Elding – 2 – Idenors Kensi 2000, Åkre Flamman 2001</li>



<li>Järvsöfaks – 2 – Eldsiri 2009, Uggla I Mossen 2016</li>



<li>Järvsöviking – 2 – Hulte Nova 2012, Åsrud Vilja 2013</li>



<li>Spikeld – 2 – Vinter Gry 2004, Finspika 2007</li>



<li>Åsajerven – 2 – Aase 2015, Voje Maren 2018</li>
</ul>

Fokustema
Det snackas om Kallblodskriteriet
Läs senare
Plock: Går det att besegra Norge?
Hamres obesegrade talang. Kriteriekungen Perssons dubbla hopp. 7 x Tjomsland. 2-2 i uttagningsloppen till Kriteriestoet. Toppmammor bakom Kriteriehästar. Eldings enorma dominans. Snabbast i historien.
Här är smått & gott inför Svenskt Kallblodskriterium och Kriteriestoet på Dannero.
Här är smått & gott inför Svenskt Kallblodskriterium och Kriteriestoet på Dannero.
