
<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 idag 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.</p>



<p>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>Bergsåkertränaren Robert Skoglund är titelförsvarare i Svenskt Kallblodskriterium, sedan Ulf Ohlsson styrt <strong>Gör Som Jag Vill</strong> (e. Järvsö Björn) till seger – trots galopp cirka halvvarvet från mål – i fjolårets blöta upplaga. Robert kommer välbeställd även till årets Kriterium med två finalister, försöksvinnaren <strong>Ängsrask</strong> (e. Bork Odin) och <strong>Hu Så Hemskt</strong> (e. Järvsö Björn), lillebror till fjolårsvinnaren.<br>– Jag tror att någon av mina hästar vinner. Ängsrask känns bara fin i träning efter kvalet och Hu Så Hemskt blir bara bättre och bättre och är den som gått fram mest, säger Robert Skoglund.</p>



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



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



<ol class="wp-block-list">
<li><strong>Ängsrask</strong> (e. Bork Odin) – Ulf Ohlsson (Robert Skoglund)</li>



<li><strong>Grude Nils</strong> (e. Grisle Odin G.L.) – Kjetil Djöseland</li>



<li><strong>Tangen Nils</strong> (e. Bork Odin) – Tom Erik Solberg (Öystein Tjomsland)</li>



<li><strong>Davidson R.F.</strong> (e. Tekno Jerven) – Marcus Lilius (Jan-Olov Persson)</li>



<li><strong>Hu Så Hemskt</strong> (e. Järvsö Björn) – Mats E Djuse (Robert Skoglund)</li>



<li><strong>Bjarte Kiro</strong> (e. Bäcklös Uriel) – John Östman (Jerker Bjurman)</li>



<li><strong>Karlängs Jerven</strong> (e. Tekno Jerven) – Jan-Olov Persson</li>



<li><strong>Bato Prinsen</strong> (e. Bork Odin) – Stefan Edin</li>



<li><strong>Kattelbo Elon</strong> (e. Tekno Odin) – Oskar Kylin Blom</li>



<li><strong>Skinnes Storm</strong> (e. Bork Odin) – Johan Kringeland Eriksen</li>



<li><strong>Oddfax</strong> (e. Odd Herakles) – Örjan Kihlström (Oskar Kylin Blom)</li>



<li><strong>Hög Erbäst</strong> (e. Art Kjarvald) – Ingvar Nyberg (Wiktor Kylin Blom)</li>
</ol>



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



<p class="has-drop-cap">Det är norsk favör – 18-14 – i Svenskt Travkriterium genom tiderna när det gäller tränarnas hemland. Årets mest långväga gäst är Forustränaren Kjetil Djöseland, som av geografiska orsaker sällan gästar Sverige med sina hästar. Han kan dock stoltsera med andraplatsen i Svenskt Kallblodsderby för <strong>Smedheim Solan</strong> (e. Bork Odin) 2011 och silverplats i Elitkampen med <strong>Kleppe Slauren</strong> (e. Sundbo Kravall) 2017.</p>



<p>Dessutom gästade han tidigare i sommar Sverige med fjolårets norske Kriterievinnare <strong>Gigant Tider</strong> (e. Norheim Svenn), som lekte hem Prinsessan Madeleines Pokal i Bollnäs.</p>



<p>Gigant Tider var aldrig anmäld till de svenska klassikerna, men dit har Djöseland siktat med <strong>Grude Nils</strong> (e. Grisle Odin G.L.), som efter en pangstart från elftespår bakom bilen (!) satt i ledning efter 150 meter.<br>– Det är en väldigt fin häst, stor och välutvecklad för att vara bara tre år. Det löste sig bra i starten, hästen är förnuftig och är egentligen komplett, sade Djöseland efter kvalet.</p>



<p>Långväga gäst var det – Kjetil Djöseland reser från Kleppe söder om Stavanger till Dannero, en tur på 115 mil enkel resa! Djöseland hade planer på att låta Grude Nils stanna i Sverige mellan försök och final, men tyckte att hästen rest, ätit och druckit så bra på vägen till kvalet att han valde att resa hem till Kleppe.</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">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.</p>



<p>Två chanser har han att fylla på med ytterligare en seger genom <strong>Davidson R.F.</strong> (e. Tekno Jerven) och <strong>Karlängs Jerven</strong> (e. Tekno Jerven). Den sistnämnde kör Persson själv.</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örra året med Robert Skoglund-tränade Gör Som Jag Vill (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/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">Förutom Robert Skoglund och Jan-Olov Persson har ytterligare en svensk tränare kvalat in två hästar till Kriteriet. Oskar Kylin Blom lotsade både <strong>Kattelbo Elon</strong> (e. Tekno Odin) och <strong>Oddfax</strong> (e. Odd Herakles). I finalen kör han själv Kattelbo Elon.<br>– Han gjorde det riktigt bra i försöket då han hade varit borta i två månader inför den starten. Visst fick han en fin resa, men det känns som att han har gått framåt väldigt mycket av det loppet då det är en helt annan spänst i kroppen efteråt. Om vi inte möter några överdjur i Ängsrask och Grude Nils kan han vara med och strida då hästen har högre kapacitet än han fått visa, säger Oskar Kylin Blom stallets hemsida.</p>



<p>Örjan Kihlström får chansen bakom Oddfax.<br>– Han var väldigt positiv i sitt försök och svarade för sitt bästa lopp hittills i karriären där han gick en bra trudelutt sista 600-700 meterna, säger Oskar Kylin Blom.</p>



<p>Kylin Bloms duo har minst rutin i fältet – fyra starter – tillsammans med brodern Wiktor Kylin Bloms finalist <strong>Hög Ersbäst</strong> (e. Art Kjarvald). Och Wiktor hur det känns att vinna Svenskt Kallblodskriterium. 2019 satt han ju bakom <strong>Bäcklös Uriel</strong> (e. Smedheim Solan). Oskar har å sin sida varit tvåa i Kriteriet med brodern <strong>Bäcklös Faron</strong> (e. Järvsö Tore).</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>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/08/jarvsofakselding-617x333.jpg" alt="" class="wp-image-105331"/><figcaption class="wp-element-caption">Järvsöfaks och Elding. Två giganter i kallblodsaveln. Foto Mathias Hedlund/Sulkysport och Claes Kärrstrand</figcaption></figure>



<p>Själv är han pappa till fyra vinnare. Han är farfar till sju vinnare (Lome Elden och Moe Odin har tre vinnare vardera och Horgen Tore en). Han är farfars far till fem vinnare (Tekno Odin och Lome Kongen två vinnare var och Lome Brage en) och farfars farfar till både Bäcklös Uriel, som har Smedheim Solan som pappa, och 2024 års vinnare Overvik Prinsen (e. Will Prinsen e. Tekno Odin).</p>



<p>När det gäller fjolårets segrare i Svenskt Kallblodskriterium finns det dubbla doser Elding i stamtavlan. Han är både farmors farfar och morfarsfar. </p>



<p>19–11 ä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>



<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. <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>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/06/backlosurielmal-617x333.jpg" alt="" class="wp-image-459163"/><figcaption class="wp-element-caption">Bäcklös Uriel och Mats E Djuse. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>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 sex år sedan på 1.25,6a/2.140 meter.<br>Den tiden står sig fortsatt som svenskt rekord över medeldistans med autostart. Ifjol vann Robert Skoglunds <strong>Gör Som Jag Vill</strong> på 1.27,1a med galopp.</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>



<p class="has-drop-cap">Just Bäcklös Uriel är pappa till Skellefteåtränaren Jerker Bjurmans finalist Bjarte Kiro, som vunnit två av sex starter. Denne har Kriterieblod i ådrorna, då mamma <strong>Ängskalla</strong> (e. Skaffer Brunen) kvalade in till Kriteriestoet 2010 via andraplats i försöket.</p>



<p>För Bjurman är det första finalisten i Svenskt Kallblodskriterium. Han har sedan tidigare tagit fram sju finalister i stoklassen, där <strong>Katla Kiro</strong> (e. Lome Elden) lyckats bäst som tvåa, medan <strong>Marre R.F.</strong> (e. Moe Svarten) och <strong>Holter Oda</strong> (e. Bork Odin) tagit tredjeplatser.</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/07/batotosen2-617x333.jpg" alt="" class="wp-image-746366"/><figcaption class="wp-element-caption">Bato Tösen och Stefan Edin. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap"><strong>Bato Tösen</strong> (e. Bork Odin) galopperade under vägen i Kriteriestoet 2021, men slutade ändå tvåa bakom <strong>Dunungen</strong> (e. Smedheim Solan). Nu får tränaren och kusken Stefan Edin och Bato Tösens mamma <strong>Järvsö Monsterkarin</strong> (e. Järvsöviking) chans till revansch.</p>



<p>Moderns sista avkomma <strong>Bato Prinsen</strong> (e. Bork Odin) räddade sista finalplatsen trots galopp och har visat god fart i karriärens inledning.</p>


<div class="factbox full ">
<div class="insidefactbox">
<div class="overflow">
<div class="height">
<div class="padding">
<div class="factvinjett">Fakta</div>
<h3 class="title">
									Ägare/uppfödare Svenskt Kallblodskriterium								</h3>
<div class="content">
<p><em>Häst – Ägare – Uppfödare</em></p>
<ol class="wp-block-list">
<li><strong>Ängsrask</strong> – Benny Grafström, Sundsvall Nyström Jenny &amp; Olsson Daniel</li>
<li><strong>Grude Nils</strong> – Martin Hove, Norge – Martin Hove, Norge</li>
<li><strong>Tangen Nils</strong> – Nils Munkhaugen Holding AS, Norge – Jörn Gunnar Nilsen, Norge</li>
<li><strong>Davidson R.F.</strong> – Stall Beaver HB &amp; Torsten Hammargren – Frida &amp; Robert Hammarström</li>
<li><strong>Hu Så Hemsk</strong> – Robert Skoglund, med flera – Menhammar Stuteri AB, Ekerö</li>
<li><strong>Bjarte Kiro</strong> – Stall Kiro AB, Skellefteå – Stall Kiro AB, Skellefteå</li>
<li><strong>Karlängs Jerven</strong> – Jan Götz, Huddinge – Anders Nilsson, Matfors</li>
<li><strong>Bato Prinsen</strong> – Ofcourse KB, Kovland – Barbro &amp; Tomas Hennersson</li>
<li><strong>Kattelbo Elon</strong> – Ulf Blom, Östervåla – Ulf Blom &amp; Ulla Hammarstedt</li>
<li><strong>Skinnes Storm</strong> – Glenn Arne Githmark, Norge – Lovise Mohaugen &amp; Knut Andresen, Norge</li>
<li><strong>Oddfax</strong> – Easy KB, Uppsala – Anders &amp; Anette Carlsson</li>
<li><strong>Hög Erbäst</strong> – Ofcourse KB, Kovland – Camilla A Röste, Hudiksvall</li>
</ol></div>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/05/majblomster1-617x333.jpg" alt="" class="wp-image-723548"/><figcaption class="wp-element-caption">Majblomster blev första svenska kallblodssto under 1.20 på Solvalla 2025. 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), <strong>Majblomster</strong> (e. Tekno Odin) och ifjol <strong>Hertiginnan Stöen</strong> (e. Tekno Odin).</p>



<p>Om det ska bli en femte raka titel i loppet är det upp till <strong>Kim Vild</strong> (e. Eld Rask) eller <strong>Järvsö Britt Marie</strong> (e. Tekno Odin), som är Perssons hopp i loppet. Men duon slår ur underläge efter fjärdeplatser i försöken och spår åtta respektive spår tolv i finalen.</p>



<p>Notablet är att bakom loppets 26 vinnare står hela 19 olika tränare och förutom Persson och Öystein Tjomsland (två vinster) 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, Heriginnan Stöen 2024</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 norrmannen Jan Roar Mjölneröd. som vann två av tre försök och dessutom hade de två snabbaste vinnarna i duon <strong>Mjölner Tyra</strong> (e. Ängsborken), 1.30,3a, och <strong>Kleppe Nissemor</strong> (e. Norheim Svenn), 1.30,4a.</p>



<p>Mjölneröd kör Mjölner Tyra, som han är både uppfödare och ägare till.<br>– Om hon håller temperamentet i schack är hon väldigt bra. Det var en bra känsla, men det är unghästar och man vet inte. Hon gjorde jobbet på fint sätt, sade Jan Roar Mjölneröd han efter försöksvinsten.</p>



<p>Norrmannen har vunnit svenska Kriteriestoet en gång tidigare, 2014 med <strong>Brenne Rödi</strong> (e. Horgen Tore). Brenne Rödi vann även norska Stokriteriet.</p>



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



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



<ol class="wp-block-list">
<li>Dragsveds Athena (e. Bäcklös Uriel) – Oskar Kylin Blom</li>



<li>Kleppe Nissemor (e. Norheim Svenn) – Christina Kjenner (Jan Roar Mjölneröd)</li>



<li>Brenne Olivia (e. Tekno Jerven) – Vidar Hop (Frode Hamre)</li>



<li>Mjölner Tyra (e. Ängsborken) – Jan Roar Mjölneröd</li>



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



<li>Tekla (e. Tekno Odin) – Sandra Eriksson</li>



<li>Läckra Louise (e. Bork Odin) – Robert Wilhelmsson</li>



<li>Kim Vild (e. Eld Rask) – Marcus Lilius (Jan-Olov Persson)</li>



<li>Jonases Lykka (e. Tekno Odin) – Jan-Olov Åberg</li>



<li>Ängsmolly (e. Norheim Faksen) – Kajsa Frick</li>



<li>Modiga Re (e. Ängsborken) – Örjan Kihlström (Rikard Häggström)</li>



<li>Järvsö Britt Marie (e. Tekno Odin) – Mats E Djuse (Jan-Olov Persson)</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/2025/05/brenneborken-617x333.jpg" alt="" class="wp-image-723526"/><figcaption class="wp-element-caption">Nye världsrekordhållaren Brenne Borken travade 1.17,7a/1.640 meter. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Den tredje försöksvinnaren kom också från Norge i Frode Hamre-tränade <strong>Brenne Olivia</strong> (e. Tekno Jerven), som vann på 1.31,6a. Vidar Hop körde Hamres häst – precis vilket som var fallet i Kriteriet för två år sedan när duon stod bakom vinnaren <strong>Overvik Prinsen</strong> (e. Will Prinsen).</p>



<p>Brenne Olivia tog fjärde segern på fem starter, men körande Vidar Hop var inte helt tillfreds efter försöket.<br>– Hon är väldigt snabb och lätt och fin att köra, hon gör allt man begär av henne. Hon var dock inte som bäst idag och borde ha vunnit lättare. Den långa resan och värmen kan vara orsaken. Hon har potential att springa väldigt fort, sade Vidar Hop efteråt.</p>



<p>Brenne Olivias mamma <strong>Brenne Berna</strong> (e. Bork Odin), 1.24,7k/1.183.296 NOK, var själv tvåa i Kriteriestoet på Dannero och kommer själv från en fantastisk syskonskara med världens snabbaste kallblod <strong>Brenne Borken</strong> (e. Bork Odin) i spetsen – <a href="https://sulkysport.se/brenne-borkens-varldsrekord-1-177/" target="_blank" rel="noreferrer noopener">läs om världsrekordet här</a>! Här finns också dubbelmiljonärerna <strong>Brenne Rödi</strong> (e. Horgen Tore), <strong>Brenne Blissi</strong> (e. Lome Elden) och <strong>Brenne Odin</strong> (e. Moe Odin). Ytterligare ett syskon är <strong>Brenne Bas</strong> (e. Horgen Tore), Kriterievinnare på Dannero 2020.</p>



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



<p class="has-drop-cap">Tre tränare har kvalat in hästar till både Kriteriet och Kriteristoet: Jan-Olov Persson, Oskar Kylin Blom och Öystein Tjomsland. Kylin Bloms <strong>Dragsveds Athena</strong> (e. Bäcklös Uriel) var tvåa i sitt försök och Gävletränaren valde innerspår i finalen när chansen fanns.</p>



<p>– Hon har varit väldigt fin i varje lopp, men senast var jag lite besviken på henne då hon tappade för mycket över upploppet. Samtidigt var hon nog nedsatt av värmen då hon inte hade druckit ordentligt. Hon öppnar bra och förhoppningsvis får vi rygg på Brenne Olivia. Skulle hon sedan vara trea-fyra är jag jättenöjd, säger Oskar Kylin Blom på sin hemsida.</p>



<p>Ytterligare en Gävletränare kvalade in en häst till final. Robert Wilhelmssons <strong>Läcka Louise</strong> (e. Bork Odin) rekordsänkte med 2,1 sekunder när hon börgade finalbiljetten.</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/07/jonaseslykkaheataln-617x333.jpg" alt="" class="wp-image-749978"/><figcaption class="wp-element-caption">Jonases Lykka och Jan-Olov Åberg i samband med kvalloppet förra hösten på 1.46,2. I försöket till Kriteriestoet travade hon 16 sekunder snabbare och det finns mer att ge i söndagens final. Foto Christer Norin/ALN</figcaption></figure>



<p class="has-drop-cap">En av svenskarna som vunnit Kriteriestoet som kusk är Bollnästränaren Jan-Olov Åberg. 2012 styrde han Leif Jonsson-tränade <strong>Hulte Nova</strong> (e. Järvsöviking) till överraskande seger.</p>



<p>I år sitter Åberg upp bakom en en egentränad häst i <strong>Jonases Lykka</strong> (e. Tekno Odin). Hon rekordsänkte med nästan tre sekunder i kvalet och har tjänat mest av alla deltagare i kriteriestoet med 150.000 kronor på kontot efter fyra starter (2-2-0).</p>



<p>– ”Lykka” har gjort det jättebra! I försöket blev det lite dåligt tempo mitt i loppet och sedan en snabb avslutning. Jag fokuserade mest på att hålla henne i rätt stil över upploppet och inte försöka nå Mjölneröds häst som vann (Mjölner Tyra, reds.anm). I finalen får det gärna bli jämn fart hela vägen. Det trivs min häst bättre med och då går hon alltid till slut. Jag har en positiv känsla inför söndagen att hon i varje fall ska kunna få med sig fina pengar hem, säger Jan-Olov Åbergs till Sulkysport.</p>



<p><a href="https://sulkysport.se/aberg-med-tva-kalla/" target="_blank" rel="noreferrer noopener">––> Läs hela intervjun med Jan-Olov Åberg häst!</a></p>



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



<p class="has-drop-cap">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>). En B-tränad häst finns med även i årets final i Rikard Häggström-tränade <strong>Modiga Re</strong> (e. Ängsborken).</p>



<p>Örjan Kihlström kör hästen i finalen och Solvallakusken vet även hur man vinner Kriteriestoet för kallblod. Två gånger tidigare har han segrat i loppet: 2016 med <strong>Uggla I Mossen</strong> (e. Järvsöfaks) och 2021 med <strong>Dunungen</strong> (e. Smedheim Solan). Båda hästarna var uppfödda på Menhammar Stuteri och ägda av Stall Segerhuva.</p>



<p>Flest kusksegrar har Mats E Djuse som vunnit de tre senaste upplagorna.</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/2021/10/sandraeriksson1-617x333.jpg" alt="" class="wp-image-226435"/><figcaption class="wp-element-caption">Sandra Eriksson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Bodentränaren Sandra Eriksson förknippas mest med varmblod, men strax före jul tog hon en gulddivisionssseger i Finland med snabblopparen <strong>Gorm</strong> (e. Dotterud Teddy). I stallet finns nu två tvåriga kallblodsston i <strong>Gorma</strong> (e. Gorm) och <strong>Polar Donna</strong> (e. Tekno Odin), men framför allt söndagens Kriteriestofinalist <strong>Tekla</strong> (e. Tekno Odin).<br>Efter tre segrar på fyra starter blev det en tredjeplats från ledningen i försöket för Tekla.</p>



<p>Sveriges mest framgångsrika kvinnliga kusk Kajsa Frick kvalade också in till finalen, när hon styrde egentränade <strong>Ängsmolly</strong> (e. Norheim Faksen) till tredjeplatsen.</p>



<p>Ängsmollys mamma <strong>Granetta</strong> (e. Tekno Odin), 1.21,0ak/1.413.459 kr, var en topphäst på banan och är fortsatt innehavare av två svenska rekord för femåriga ston. Ängsmolly är första avkomman.<br>Granetta är syster med Kriterievinnaren <strong>Lome Felix</strong> (e. Lome Kongen) och miljonäskan <strong>Puma Jerva</strong>, som själv är mamma till avelshingstarna <strong>Ängsborken</strong> (e. Bork Odin) och <strong>Tekno Jerven</strong> (e. Tekno Odin).</p>



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



<p class="has-drop-cap">Johanna Frunck, Chloe Pettersson och Isabell Isaksson är tjejerna som har extra fullt upp i finalerna. De har nämligen till vardags hand om två finalister vardera. Johanna och Chloe har en duo i Kriteriet, medan Isabell selar ut två hästar i Kriteriestoet.</p>



<p>För Johanna kan det bli Kriterieseger för andra året i rad. Ifjol vann hennes passhäst Gör Som Jag Vill (e. Järvsö Björn).</p>



<p><strong>Hästskötare – Svenskt Kallblodskriterium</strong></p>



<ol class="wp-block-list">
<li>Ängsrask – Johanna Frunck</li>



<li>Grude Nils – Maylen Lode</li>



<li>Tangen Nils – Celine Fåland Hansen</li>



<li>Davidson R.F. – Chloe Pettersson</li>



<li>Hu Så Hemsk – Johanna Frunck</li>



<li>Bjarte Kiro – Ranja Burman</li>



<li>Karlängs Jerven – Chloe Pettersson</li>



<li>Bato Prinsen – Per Engman</li>



<li>Kattelbo Elon – Lisa Lindqvist</li>



<li>Skinnes Storm – Leni Holen Berg</li>



<li>Oddfax – Fanny Blom</li>



<li>Hög Erbäst – Johanna Karlsson</li>
</ol>



<p><strong>Hästskötare – Kriteriestoet</strong></p>



<ol class="wp-block-list">
<li>Dragsveds Athena – Elvira Klingvall</li>



<li>Kleppe Nissemor – Christina Kjenner</li>



<li>Brenne Olivia – Tina Storetvedt</li>



<li>Mjölner Tyra – Christina Kjenner</li>



<li>Tangen Merete – Kamilla Bertelsen</li>



<li>Tekla – Suvi Heikkinen</li>



<li>Läckra Louise – Madelene Johansson</li>



<li>Kim Vild – Isabell Isaksson</li>



<li>Jonases Lykka – Johanna Stark</li>



<li>Ängsmolly – Emma Lind</li>



<li>Modiga Re – Stina, Viktor &#038; Elsa Häggström</li>



<li>Järvsö Britt Marie – Isabell Isaksson</li>
</ol>


<div class="factbox full ">
<div class="insidefactbox">
<div class="overflow">
<div class="height">
<div class="padding">
<div class="factvinjett">Fakta</div>
<h3 class="title">
									Ägare/uppfödare Kriteriestoet								</h3>
<div class="content">
<p><em>Häst – Ägare – Uppfödare</em></p>
<ol class="wp-block-list">
<li><strong>Dragsveds Athena</strong> – OKB Stable AB, med flera – Jenny Wästerhed, Bjuråker</li>
<li><strong>Kleppe Nissemor</strong> – Jan Roar Mjölneröd, Norge – Sigmund Öksnevad, Norge</li>
<li><strong>Brenne Olivia</strong> – Jan Petter Sissener, Norge – Vidar A Brenne, Norge</li>
<li><strong>Mjölner Tyra</strong> – Jan Roar Mjölneröd, Norge – Jan Roar Mjölneröd, Norge</li>
<li><strong>Tangen Merete</strong> – Nls Munkhaugen Holding AS, Norge – Jörn Gunnar Nilsen, Norge</li>
<li><strong>Tekla</strong> – Countess AB, Luleå – Countess AB, Luleå</li>
<li><strong>Läckra Louise</strong> – Stallbutiken i Sandviken HB – Anders Pålerfält, Sandviken</li>
<li><strong>Kim Vild</strong> – AB Johan Hansson, Uppsala – Theresa Anlér, Uppsala</li>
<li><strong>Jonases Lykka</strong> – Conny &amp; Annika Kramme – Conny &amp; Annika Kramme</li>
<li><strong>Ängsmolly</strong> – Stall Puma – Lars-Erik H &amp; Hans-Åke Karlsson</li>
<li><strong>Modiga Re</strong> – Rikard &amp; Ida-Maria Häggström – Reidun Böhn, Årjäng</li>
<li><strong>Järvsö Britt Marie</strong> – Stall Nybondgården – Jan-Olov Persson, Hudiksvall</li>
</ol></div>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>



<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="bN6YhGvGv5"><a href="https://sulkysport.se/aberg-med-tva-kalla/">Dannero V75: Åberg med två kalla</a></blockquote><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; visibility: hidden;" title="”Dannero V75: Åberg med två kalla” &ndash; Sulkysport" src="https://sulkysport.se/aberg-med-tva-kalla/embed/#?secret=AsC45J1UaI#?secret=bN6YhGvGv5" data-secret="bN6YhGvGv5" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe>
</div></figure>
