
<p class="has-drop-cap">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 i söndagens final får 500.000 kronor.<br>Det första Kriteriestoet korades så sent som 1999 då <strong>Buaas Jansi</strong> (e. Alm Svarten-Giklingstjerna) fick det i sammanhanget mycket blygsamma förstapriset 30.000 kronor.<br>Sedan 2022 är könen precis som på fyraåringssidan uppdelade och jämställa, så även i Kriteriestoet väntar en halv miljon kronor på vinnaren.</p>



<p>Den store förhandsfavoriten i Kriteriet är norske <strong>Björli Bas</strong> (e. Brenne Bas), som gjort fem starter och vunnit samtliga. I näst senaste starten i ett treåringslopp på Jarlsberg vann han på 1.25,0a/2.100 meter tillsammans med sin tränare Öystein Tjomsland, som tränar tre finalister.<br>– Björli Bas har varit otroligt bra och utvecklats för varje start. Det har varit enkelt varje gång och riktigt vassa avslutningar, han travade 1.19,9 sista 500 i debuten, säger Öystein Tjomsland.</p>



<p>Björli Bas tillhör sin pappa <strong>Brenne Bas</strong> första kull. Denne var Tjomslands senaste vinnare i svenska Kriteriet.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/07/bjorlibas-617x333.jpg" alt="" class="wp-image-876584"/><figcaption class="wp-element-caption">Björli Bas tog femte raka segern i Kriteriekvalet tillsammans med Öystein Tjomsland. Skärmbild ATG Live</figcaption></figure>



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



<p>2.140 meter autostart, Dannero 2 augusti<br><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li><strong>Minell</strong> (e. Bork Odin) – Vidar Tjomsland (Stine Birkeland)</li>



<li><strong>Bäcklös Borken</strong> (e. Tangen Bork) – Oskar Kylin Blom</li>



<li><strong>Björli Bas</strong> (e. Brenne Bas) – Öystein Tjomsland</li>



<li><strong>Troll Knut</strong> (e. Art Kjarvald) – Ulf Ohlsson (Jan Ove Olsen)</li>



<li><strong>Will Borken</strong> (e. Tangen Bork) – Johan Kringeland Eriksen</li>



<li><strong>Järvsö Jan</strong> (e. Järvsö Björn) – Daniel Wäjersten (Jan-Olov Persson)</li>



<li><strong>Ängsson</strong> (e. B.W.Modde) – Jan Ove Olsen</li>



<li><strong>Skiffer</strong> (e. Lome Brage) – Mats E Djuse (Jan-Olov Persson)</li>



<li><strong>Kjölstad Gutten</strong> (e. Grisle Odin G.L.) – Tom Erik Solberg (Öystein Tjomsland)</li>



<li><strong>Tekno Ture</strong> (e. Tekno Odin) – Rikard N Skoglund (Öystein Tjomsland)</li>



<li><strong>Lannem Pål</strong> (e. Tekno Odin) – Vidar Hop (Erik Killingmo)</li>



<li><strong>L.Q.Laban</strong> (e. Briskeby Philip) – Ingvar Nyberg (Wiktor Kylin-Blom)</li>
</ol>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/10/backlosfaronokb-617x333.jpg" alt="" class="wp-image-114874"/><figcaption class="wp-element-caption">Bäcklös Faron och Oskar Kylin Blom. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Oskar Kylin Blom var tvåa med egentränade <strong>Bäcklös Faron</strong> (e. Järvsö Tore) när Tjomsland vann med Brenne Bas 2020 och bannade sig själv efter silverpengen.<br>– Jag var sjukt besviken på mig själv efter loppet. Det är tävling vi håller på med och jag tävlade inte. Om jag kört lite fortare hade aldrig Tjomsland kommit förbi och då tror jag att vi kunnat vinna loppet, sade Oskar Kylin Blom efteråt.</p>



<p>I år har han en ny chans med obesegrade <strong>Bäcklös Borken</strong> (e. Tangen Bork), vars mamma <strong>Bäcklös Yrja</strong> (e. Järvsö Tore) är syster till Bäcklös Faron och Kriterievinnaren Bäcklös Uriel (e. Smedheim Solan), 1.18,7ak*/2.756.833 kr.</p>



<p>Vägen till Kriteriet var krokig för Bäcklös Borken och hästen blev underkänd i kvallopp i oktober som tvååring på grund av orent trav. Förhoppningarna på treåringssäsongen var länge låga, men till debuten i mitten av juni hade det hänt något.<br>– De som såg den här hästen för ett par månader sedan hade väl aldrig kunnat tro att jag skulle köra så här fort med honom i debuten. Och det trodde jag inte själv heller egentligen. Vi hade i princip gett upp förra året och jag tänkte bara att vi skulle klara ett kval för att få de där tio tusen kronorna, sade Oskar Kylin Blom efter debutsegern.</p>



<p>Nu kommer hästen till Kriteriet med tre raka segrar.<br>– Bäcklös Borken var jättefin i sitt försök. Det blev visserligen inget tufft lopp, men han vann på väldigt bra sätt där han både öppnade snabbt och avslutade snabbt. Drömmen är att ta oss till ledningen initialt, sedan finns det olika valmöjligheter. Det ska bli kul att se hur han står sig när han får möta de bästa. Vi lättar i balansen till aluminiumskor bak, sedan blir det även första gången med halvstängt norskt huvudlag, säger Oskar Kylin Blom på sin hemsida.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/07/janolovpersson47-617x347.jpg" alt="" class="wp-image-102065"/><figcaption class="wp-element-caption">Jan-Olov Persson. Foto Mia Törnberg/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Det är norsk favör – 19-14 – i Svenskt Travkriterium genom tiderna när det gäller tränarnas hemland, men en svensk har vunnit flest gånger.</p>



<p>Jan-Olov Persson har sedan premiärsegern med Järvsöfuxen vunnit Kallblodskriteriet fem gånger till som tränare och med sex tränarsegrar står han i särklass i Kriteriehistorien.<br>Två chanser har han att fylla på med ytterligare en seger genom <strong>Järvsö Jan</strong> (e. Järvsö Björn) och <strong>Skiffer</strong> (e. Lome Brage).</p>



<p><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">***</p>



<p class="has-drop-cap">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 Ulf Ohlsson som vunnit flest Kriterier, fyra. Den senaste kom för två år sedan med Robert Skoglund-tränade <strong>Gör Som Jag Vill</strong> (e. Järvsö Björn).</p>



<p><strong>Kuskar med två eller fler vinnare:</strong></p>



<ul class="wp-block-list">
<li>Ulf Ohlsson – 4 – Wik Elden 2008, Tekno Eld 2017, Eld Rask 2018, Gör Som Jag Vill 2024</li>



<li>Jomar Blekkan – 3 – Alm Rau Jo 2001, Frisli To Jo 2003, Slått Eld 2005</li>



<li>Vidar Hop – 2 – H.G.Balder 2004, Overvik Prinsen 2023</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">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/08/janoveolsen-617x333.jpg" alt="" class="wp-image-618505"/><figcaption class="wp-element-caption">Jan Ove Olsen. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Förutom Jan-Olov Persson har även Hagmyrentränaren kvalat in två hästar till Kriteriet. Ulf Ohlsson kör <strong>Troll Knut</strong> (e. Art Kjarvald), som är snabbast av de svenskfödda finalisterna. I försöket travade han 1.27,1 som tvåa bakom norske Minell (e. Bork Odin).</p>



<p>Jan Ove Olsen kör själv <strong>Ängsson</strong> (e. B.W.Modde) och duon är hans första finalister i svenska Kriteriet som tränare.</p>



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



<p class="has-drop-cap">En som har Kriterierutin sedan tidigare är Hagmyrenkollegan Wiktor Kylin-Blom. Han har kvalat in häst till båda finalerna i <strong>L.Q.Laban </strong>(e. Briskeby Philip) i Kriteriet och<strong> L.Q.Tira</strong> (e. Art Kjarvald) i Kriteriestoet. <br>Som tränare har han tagit del av prispotten med <strong>Bäcklös Olle</strong> (e. Horgen Tore) och <strong>Hög Erbäst</strong> (e. Art Kjarvald) som tagit varsitt sjättepris i finalerna de senaste två åren.</p>



<p>Dessutom är han en av elva svenska kuskar som vunnit Svenskt Kallblodskriterium. Den 11 augusti 2019 var den stora dagen när Nicklas Blom-tränade <strong>Bäcklös Uriel</strong> (e. Smedheim Solan) vann klassikern på Dannero med Wiktor i vagnen.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/06/wiktorkylinblom-617x333.jpg" alt="" class="wp-image-172365"/><figcaption class="wp-element-caption">Wiktor Kylin-Blom. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Wiktor var förstekusk bakom Bäcklös Uriel som unghäst, men var avstängd i Kriteriekvalet då broder Oskar fick hoppa upp. I finalen var Wiktor tillbaka och gjorde inga misstag när Bäcklös Uriel segrade från ledningen.</p>



<p>Bäcklös Uriel blev 2023 Sveriges näst snabbaste kallblod genom tiderna när han vann på 1.18,7a/1.640 meter i Bollnäs – bara Järvsöfaks är snabbare – men finns tyvärr inte längre i livet.</p>



<p>På söndag väljer Kriterievinnaren Wiktor Kylin-Blom att stå vid sidan och hemmakusken Ingvar Nyberg kör båda hans finalister.</p>



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



<p class="has-drop-cap">På tal om dubblar…uppfödare till Wiktor Kylin-Bloms båda finalister <strong>L.Q.Laban</strong> och <strong>L.Q.Tira</strong> är Linette Boström från Hudiksvall. Hon har tre fölstion och fick två föl för tre år sedan. Båda dessa står på startlinjen i treåringarnas största lopp!</p>



<p>– För Jan-Olov Persson fick jag en dag fick chansen att jobba med stuteriverksamheten hos Hudik Stallions. Jag var där tre eller fyra somrar och fick upp ögonen för det här med avel under de åren. Jag fick ju även koll på…hur man gör, eller vad jag ska säga. Jag fastnade för det här med fölen och hela hanteringen runt dem, säger Linette Boström som bland annat jobbar som arbetsterapeut.</p>



<p><a href="https://sulkysport.se/kallblodskriteriet-linettes-osannolika-facit/" target="_blank" rel="noreferrer noopener">––> Läs Sulkysports intervju med Linette Boström inför Kriteriedagen här!</a></p>



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



<p class="has-drop-cap">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>Själv är han pappa till fyra vinnare. Han är farfar till åtta vinnare (<strong>Lome Elden</strong> och <strong>Moe Odin</strong> har tre vinnare vardera och <strong>Horgen Tore</strong> samt <strong>Grisle Odin G.L.</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 både <strong>Bäcklös Uriel</strong>, som har <strong>Smedheim Solan</strong> som pappa, och 2024 års vinnare <strong>Overvik Prinsen</strong> (e. Will Prinsen e. Tekno Odin).</p>



<p>21–12 är ställning i norsk favör när det gäller vinnarnas födelseland.</p>



<p><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">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/08/maritaarvidsson-617x333.jpg" alt="" class="wp-image-201780"/><figcaption class="wp-element-caption">Marita Arvidsson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">En hel del travhöjdare finns bland hästägarna i Kriteriefältet. Några exempel: Sleipners ordförande Marita Arvidsson är med i ägargruppen bakom Bäcklös Borken (e. Tangen Bork). I gänget som äger Lannem Pål (e. Tekno Odin) finns Kai-Magnar Killingmo (styrelseledamot i det norska travsällskapet, Svein Morten Buer (tidigare generalsekreterare i DNT) och travjournalisten Even Elvenes.</p>



<p><strong>Uppfödare och ägare i Kriteriet</strong><br><em>Häst – Uppfödare – Ägare</em></p>



<ol class="wp-block-list">
<li><strong>Minell</strong> – Hovel Helmen, Norge – Stall Elsja, Norge</li>



<li><strong>Bäcklös Borken</strong> – Nicklas Blom &#038; Kristin Persson – Ofcourse KB, Kovland</li>



<li><strong>Björli Bas</strong> – Björlia Veterinär og Avlsstasjon, Norge – Tore Gard, Norge</li>



<li><strong>Troll Knut</strong> – Opus Graph AB, Gävle – Stall Petit</li>



<li><strong>Will Borken</strong> – Rudolf &#038; Caroline Roland, Norge – Grude Travhest AS, Norge</li>



<li><strong>Järvsö Jan</strong> – Jan-Olov Persson, Hudiksvall – Stall Kålhagen – Ofcourse</li>



<li><strong>Ängsson</strong> – Jenny Nyström &#038; Daniel Olsson – Ofcourse KB, Kovland</li>



<li><strong>Skiffer</strong> – Kristin Berg, Delsbo – Ofcourse KB, Kovland</li>



<li><strong>Kjölstad Gutten</strong> – Kjell-Aage Öie-Kjölstad, Norge – Bergsåker Open Trotters KB</li>



<li><strong>Tekno Ture</strong> – Maria Arnells, Alfta – Ofcourse KB, Kovland</li>



<li><strong>Lannem Pål</strong> – Ola M Skrugstad, Norge – Stall Göy och Glede, Norge</li>



<li><strong>L.Q.Laban</strong> – Linette Boström, Hudiksvall – Ofcourse KB, Kovland</li>
</ol>



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



<p class="has-drop-cap">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. Ekeld (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>Snabbaste vinnare bland hingstar och valacker är Bäcklös Uriel (e. Smedheim Solan), som för sju år sedan på 1.25,6a/2.140 meter. Den tiden står sig fortsatt som svenskt rekord över medeldistans med autostart.</p>



<p><strong>De fem snabbaste Kriteriesegrarna är:</strong></p>



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



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



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



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



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



<p class="has-text-align-center">***</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">I oktober förra året lämnade Lannem Silje hastigt jordelivet sedan det då 15-åriga stoet ätit av en mycket giftig växt på betet. Under och efter den sagolika karriären blev hon mamma till sex avkommor, varav fem ston.</p>



<p>Dottern <strong>Lannem Stella</strong> (e. Tekno Odin), 1.27,5m/845.626 kr, vann Kriteriestoet, medan förstfödda <strong>Lannem Stina</strong> (e. Dotterud Teddy) förblev ostartad. Efter att ha fått Lannem Stina gjorde Lannem Silje comeback och travade bland annat 1.20,5 i Elitkampen, innan skorna lades på hyllan.</p>



<p>Lannem Stina kom däremot aldrig till start och har istället fått fyra avkommor. Den andra i ordningen är söndagens Kriteriefinalist <strong>Lannem Pål</strong> (e. Tekno Odin) som inledde imponerande med tre raka segrar innan han gått på pumpen i de tre senaste starterna. Han ordnade ändå Kriterieplatsen säkert som trea i försöket.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/08/hertiginnanstoen-617x333.jpg" alt="" class="wp-image-753229"/><figcaption class="wp-element-caption">Hertiginnan Stöen och Mats E Djuse. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Kriteriestoet har några år kortare historia än Kriteriet, men dominanten bland tränarna är densamme. Jan-Olov Persson ståtar med åtta tränarvinster sedan premiären 1999 och har tränat vinnarna av de fyra senaste upplagorna: <strong>Dunungen</strong> (e. Smedheim Solan), <strong>Lannem Stella</strong> (e. Tekno Odin), Majblomster (e. Tekno Odin) och för två år sedan <strong>Hertiginnan Stöen</strong> (e. Tekno Odin).</p>



<p>I år saknar Hagmyrentränaren finalist i Kriteriestoet.</p>



<p>Notabelt är att bakom loppets 27 vinnare står hela 19 olika tränare och förutom Persson och dubbelvinnarna Jan Roar Mjölneröd och Öystein Tjomsland har ingen tränare vunnit loppet fler än en gång.</p>



<p><strong>Tränare med två eller fler vinnare:</strong></p>



<ul class="wp-block-list">
<li>Jan-Olov Persson – 8 – Idenors Kessi 2000, Åkre Flamman 2001, Eldsiri 2009, Uggla I Mossen 2016, Dunungen 2021, Lannem Stella 2022, Majblomster 2023, Hertiginnan Stöen 2024</li>



<li>Jan Roar Mjölneröd – 2 – Brenne Rödi 2014, Kleppe Nissemor 2025</li>



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



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



<p class="has-drop-cap">Dominanten i uttagningsloppen var Öystein Tjomsland, som har en tredjedel av startfältet i finalen med fyra hästar. Själv kvalade han in <strong>Gunnlaila</strong> (e. Brenne Bas) och <strong>Lille Mari G.L. </strong>(e. Bork Odin) och väljer att köra den förstnämnda.<br>– Gunnlaila gjorde ett starkt lopp. Hon är stänkrädd, så jag valde att köra i dödens och visste att hon kunde klara det, säger Öystein Tjomsland om sin försökstvåa.</p>



<p>Tom Erik Solberg kvalade in de andra två hästarna från Tjomslands stall och båda ägs av Nils Munkhaugen: försöksvinnaren <strong>Tangen Ruth</strong> (e. Bork Odin) och <strong>Tangen Tyra</strong> (e. Bork Odin).</p>



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



<p>2.140 meter autostart, Dannero 2 augusti<br><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li>Tangen Ruth (e. Bork Odin) – Tom Erik Solberg (Öystein Tjomsland)</li>



<li>Förlands Lilja (e. Bork Odin) – Tom Erga</li>



<li>Gunnlaila (e. Brenne Bas) – Öystein Tjomsland</li>



<li>Troll Sterk Elvira (e. Tekno Odin) – Jan Roar Mjölneröd</li>



<li>Tangen Tyra (e. Bork Odin) – Vidar Hop (Öystein Tjomsland)</li>



<li>Haslehaugens Odine (e. Bork Odin) – Mats E Djuse (Lars O Romtveit)</li>



<li>Lille Mari G.L. (e. Bork Odin) – Vidar Tjomsland (Öystein Tjomsland)</li>



<li>Prussiluskan (e. Monster Monsun) – Ulf Ohlsson (Lars Holm)</li>



<li>Önnes Engla (e. Ängsborken) – Jan-Olov Åberg</li>



<li>L.Q.Tira (e. Art Kjarvald) – Ingvar Nyberg (Wiktor Kylin-Blom)</li>



<li>Feseth Astrid (e. Gomnes Hans T.) – Rikard N Skoglund (Jan Ove Olsen)</li>



<li>Haukfaksa (e. Pave Faks) – Johan Kringeland Eriksen</li>
</ol>



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



<p class="has-drop-cap">Kriteriestoets mest långväga gäst är storfavoriten <strong>Förlands Lilja</strong> (e. Bork Odin), som sticker en häst ut lite extra bland de tolv finalisterna. Norske Tom Ergas efter fyra starter obesegrade var snabbast från början och snabbast till slut i kvalet, där hon flög till ledningen och lämnade motståndarna sista halvvarvet i en snabb avslutning.</p>



<p>Efter segern vände hon tillbaka till Forustränaren Tom Ergas stall i Pollestad utanför Stavanger. Resvägen är omkring 110 mil enkel resa!<br>– Det är en väldigt fin häst. Hon har allt en topphäst ska ha, hon är snabb och verkar ha bra distans i sig. Det är tidigt på säsongen än, men vi får hoppas att hon fortsätter utveckling. Jag har inte haft en bättre unghäst, men jag har haft många bra hästar. Resan tar 16-17 timmar, sade Tom Erga efter utklassningen i försöket.</p>



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



<p class="has-drop-cap">Från och med 2022 är 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 Lannem Silje ä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>I Kriteriestoet är två svenskfödda vinnare snabbast i historien: <strong>Guli Anna</strong> vann tillsammans med Umåkertränaren Stefan Johansson för sju år sedan på 1.26,7a/2.140 meter och den tiden putsades med tre tiondelar av drottningen <strong>Majblomster</strong> 2023. Jan-Olov Persson tränar och Mats E Djuse körde stoet som sänkte svenska rekordet till 1.26,4.<br>En dryg månad senare travade Majblomster världsrekordet 1.23,6a/2.100 meter när hon vann Stokriteriet på Bjerke.</p>



<p>De senaste två åren har det ”räckt” att trava 1.27,8a/2.140 meter för att vinna.</p>



<p><strong>Snabbaste vinnare i Kriteriestoet:</strong></p>



<ul class="wp-block-list">
<li>2023 <strong>Majblomster</strong> (e. Tekno Odin) – Mats E Djuse, 1.26,4a/2.140</li>



<li>2019 <strong>Guli Anna</strong> (e. Bork Odin) – Stefan Johansson, 1.26,7a/2.140</li>



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



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



<li>2024 <strong>Hertiginnan Stöen</strong> (e. Tekno Odin) – Mats E Djuse, 1.27,8a</li>



<li>2025 <strong>Kleppe Nissemor</strong> (e. Norheim Svenn) – Chrstina Kjenner, 1.27,8a</li>



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



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



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/08/janolovaberg-617x333.jpg" alt="" class="wp-image-749989"/><figcaption class="wp-element-caption">Jan-Olov Åberg. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Jan-Olov Åberg hade en topplacering på gaffeln i Kriteriestoet förra året med <strong>Jonases Lykka</strong> (e. Tekno Odin). Hon svarade för en toppavslutning i tredjespår sista 700 meterna, men galopperade 30 meter från mål i kamp om andraplatsen bakom <strong>Kleppe Nissemor</strong> (e. Norheim Svenn) och troligen var det den som rök.</p>



<p>Nu har Åberg laddat om med <strong>Önnes Engla</strong> (e. Ängsborken), som varit på pallen i sex av sju starter i livet. I försöket svarade hon för en stark avslutning som tvåa efter att ha – precis som stallkamraten i finalen ifjol – fått göra jobbet i tredjespår sista 700 meterna.</p>



<p>Åberg tillhör skaran kuskar som vunnit Kriteriestoet. 2012 styrde han Leif Jonsson-tränade <strong>Hulte Nova</strong> (e. Järvsöviking) till överraskande seger.</p>



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



<p class="has-drop-cap">När huvudarbetsgivaren på kallblodssidan Jan-Olov Persson saknar starthäst bland de treåriga stona kör Kriteriestoets mest framgångsrike kusk i historien, Mats E Djuse, precis som i försöket norske tränarnestorn Lars O Romtveits <strong>Haslehaugens Odine</strong> (e. Bork Odin). </p>



<p>Mats vann Kriteriestoet tre år i rad 2022-2024 och är ensam om tre kusksegrar.</p>



<p><strong>Kuskar med två eller fler vinnare:</strong></p>



<ul class="wp-block-list">
<li>Mats E Djuse – 3 – Lannem Stella 2022, Majblomster 2023, Heriginnan Stöen 2024</li>



<li>Örjan Kihlström – 2 – 2016 Uggla I Mossen, 2021 Dunungen</li>



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



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



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/08/trollbackensolov-617x333.jpg" alt="" class="wp-image-752949"/><figcaption class="wp-element-caption">Lars Holm-tränade Trollbackens Olov och Tomas Pettersson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap"><strong>Prussiluskan</strong> (e. Monster Monsun) är katten bland hermelinerna i Kriteriestoet. Hon är nämligen den enda amatörtränade hästen i finalen. Bergsåkers Lars Holm sköter träningen och deläger hästen.</p>



<p>Lars Holm har visat upp sig i de stora sammanhangen tidigare – och på senare år. Hans hingst <strong>Trollbackens Olov</strong> (e. Odin Tabac), 1.23,2am/1.055.000 kr, var tvåa i Svenskt Kallblodskriterium för två år sedan och bara slagen med en halv längd av vinnaren <strong>Gör Som Jag Vill</strong> (e. Järvsö Björn).</p>



<p>Treåringssäsongen innehöll även tre segrar värda 100.000 kronor vardera för Trollbacken Olov. Som fyraåring bockade han av nästa storlopp när han kvalade in till Svenskt Kallblodsderby.</p>



<p>Tre svenska amatörtränare har tagit fram en vinnare i Kriteriestoet: Kent Hafstad (<strong>Karmine</strong>), Leif Jonsson (<strong>Hulte Nova</strong>) och Nina Jonsson (<strong>Myrs Hera</strong>). </p>



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



<p class="has-drop-cap">Jan Ove Olsen har en duo i Kriteriet och fyller på med en tredje finalist från stallet i Kriteriestoet genom egna uppfödningen <strong>Feseth Astrid</strong> (e. Gomnes Hans T.), som kom till kvalet med två raka segrar och ordnade finalplats som fyra.</p>



<p><strong>Uppfödare och ägare i Kriteriestoet</strong><br><em>Häst – Uppfödare – Ägare</em></p>



<ol class="wp-block-list">
<li><strong>Tangen Ruth</strong> – Jörn Gunnar Nilsen, Norge – N Munkhaugen Holding AS, Norge</li>



<li><strong>Förlands Lilja</strong> – Per-Eivind Tjordal, Norge – Stall T.A.P., Norge</li>



<li><strong>Gunnlaila</strong> – Kristin U Nedrebö, Norge – Stall Gunnlaila, Norge</li>



<li><strong>Troll Sterk Elvira</strong> – Thomas Rousalis, Norge – Stall Går For Gull, Norge</li>



<li><strong>Tangen Tyra</strong> – Jörn Gunnar Nilsen, Norge – N Munkhaugen Holding AS, Norge</li>



<li><strong>Haslehaugens Odine</strong> – Hans J &#038; Minda G Haslestad, Norge – Hans J &#038; Minda G Haslestad, Norge</li>



<li><strong>Lille Mari G.L. </strong>– Gustav Larsen, Norge – Finn Olav Nenseth, Norge</li>



<li><strong>Prussiluskan</strong> – Kjell O Eriksson, Grillby – Lars Holm &#038; Emelie Öberg</li>



<li><strong>Önnes Engla</strong> – Marie Ungman, Alfta – Jan-Olov Åberg &#038; Jan-Erik Stark</li>



<li><strong>L.Q.Tira</strong> – Linette Boström, Hudiksvall – Wiktor Kylin-Blom, Hudiksvall</li>



<li><strong>Feseth Astrid</strong> – Jan Ove Olsen, Hudiksvall – Svs Ekonomi AB &#038; Swedish Trade Int. AB</li>



<li><strong>Haukfaksa</strong> – Ketil Haukli, Norge – Ketil Haukli, Norge</li>
</ol>



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



<p class="has-drop-cap">Bakom varje topphäst står en hästskötare som lägger ned mycket tid på sina passhästar. För några av dem blir det extra hektiskt denna söndag på Dannero.</p>



<p><strong>Vilde Abusdal</strong> har en häst i vardera final i duon Björli Bas och Lille Mari G.L. Detsamma gäller <strong>Emma Mattsson</strong> med finalisterna Ängsson och Feseth Astrid. <strong>Stine Birkeland</strong> tränar själv Minell och sköter dessutom Kjölstad Gutten i Kriteriet. <strong>Maja Klaar</strong> har också dubbla Kriteriehästar i Jan-Olov Perssons duo Järvsö Jan och Skiffer. Tangen Ruth och Tangen Tyra är <strong>Celine F Hansen</strong>s två passhästar i Kriteriestoet.</p>



<p><strong>Skötarna i Svenskt Kallblodskriterium</strong><br><em>Skötare – Häst</em></p>



<ul class="wp-block-list">
<li>Stine Birkeland – Minell</li>



<li>Elvira Klingvall – Bäcklös Borken </li>



<li>Vilde Abusdal – Björli Bas </li>



<li>Silje Röste – Troll Knut </li>



<li>Leni Holen Berg – Will Borken </li>



<li>Maja Klaar – Järvsö Jan </li>



<li>Emma Mattsson – Ängsson </li>



<li>Maja Klaar – Skiffer </li>



<li>Stine Birkeland – Kjölstad Gutten</li>



<li>Anna-Karin Jonsson – Tekno Ture  </li>



<li>Fredrik Lysand – Lannem Pål </li>



<li>Maja Olofsson – L.Q.Laban</li>
</ul>



<p><strong>Skötarna i Kriteriestoet</strong><br><em>Skötare – Häst</em></p>



<ul class="wp-block-list">
<li>Celine F Hansen – Tangen Ruth</li>



<li>Annette Erga – Förlands Lilja</li>



<li>Hanna Edvinsson – Gunnlaila</li>



<li>Christina Kjenner – Troll Sterk Elvira</li>



<li>Celine F Hansen – Tangen Tyra</li>



<li>Lars O Romtveit – Haslehaugens Odine</li>



<li>Vilde Abusdal – Lille Mari G.L.</li>



<li>Emelie Öberg – Prussiluskan</li>



<li>Johanna Stark – Önnes Engla</li>



<li>Johanna Karlsson – L.Q.Tira</li>



<li>Emma Mattsson – Feseth Astrid</li>



<li>Leni Holen Berg – Haukfaksa</li>
</ul>



<figure class="wp-block-embed is-type-wp-embed is-provider-sulkysport wp-block-embed-sulkysport"><div class="wp-block-embed__wrapper">
<blockquote class="wp-embedded-content" data-secret="cDwZ91dJC5"><a href="https://sulkysport.se/kallblodskriteriet-linettes-osannolika-facit/">Kallblodskriteriet: Linettes osannolika facit</a></blockquote><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; visibility: hidden;" title="”Kallblodskriteriet: Linettes osannolika facit” &ndash; Sulkysport" src="https://sulkysport.se/kallblodskriteriet-linettes-osannolika-facit/embed/#?secret=kZ7U4dJnTj#?secret=cDwZ91dJC5" data-secret="cDwZ91dJC5" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe>
</div></figure>
