
<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>Buuas 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>Öystein Tjomsland sitter med trumf på hand inför treåringarnas klassiker. Nio av 24 finalister kommer från norrmannens framgångsrika storstall. Två av tre försöksvinnare i Kriteriet tränas av Tjomsland, däribland den i särklass snabbaste <strong>Tangen Martin</strong> (e. Bork Odin).<br>Tangen Martin körs av Tom Erik Solberg och har en närmast milslång meritlista när det gäller kallblodsklassiker, men i svenska Kriteriet har han faktiskt gått bet hittills och jagar fortsatt första triumfen.</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">Öystein Tjomsland. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



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



<p><strong>Dannero den 4 augusti</strong><br>2.140 meter autostart, förstapris: 500.000 kr:<br><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li>Grude Erling (e. Nordsjö Odin) – Vidar Tjomsland (Öystein Tjomsland)</li>



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



<li>Gargamel (e. Galileo) – Magnus A Djuse (Jan Ove Olsen)</li>



<li>Trollbackens Olov (e. Odin Tabac) – Per Linderoth (Lars Holm)</li>



<li>Gör Som Jag Vill (e. Järvsö Björn) – Ulf Ohlsson (Robert Skoglund)</li>



<li>Holms Oden (e. Bork Odin) – Tomas Pettersson (Alf Nordh)</li>



<li>Grisle Galant G.L. (e. Nordsjö Odin) – Öystein Tjomsland</li>



<li>Bäcklös Olle (e. Horgen Tore) – Wiktor Kylin-Blom</li>



<li>Mitt Hjärtas Hero (e. Tekno Odin) – Mats E Djuse (Jan-Olov Persson)</li>



<li>Bazoo Can (e. Ängsborken) – Kenneth Gorski (Kai Pakola)</li>



<li>Ellwis (e. B.W.Modde) – Ingvar Nyberg (Lennart Wedin)</li>



<li>Oppgårdens Brunte (e. Tekno Odin) – Jan-Olov Persson</li>
</ol>



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



<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>Mitt Hjärtas Hero</strong> (e. Tekno Odin) och <strong>Oppgårdens Brunte</strong> (e. Tekno Odin). 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>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/09/jomarblekkan-617x333.jpg" alt="" class="wp-image-213988"/><figcaption class="wp-element-caption">Jomar Blekkan. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<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 Jomar Blekkan och Ulf Ohlsson som vunnit flest Kriterier, tre vardera.</p>



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



<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 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 fjolårsvinnaren Overvik Prinsen (e. Will Prinsen e. Tekno Odin).</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">L<strong>ax 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. Tolv avkommor fick Elitstoet innan hon gick bort förra året och tio av dem är i startbar ålder. Samtliga har startat och alla utom en har dessutom vunnit lopp.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/05/4envis-617x333.jpg" alt="" class="wp-image-588492"/><figcaption class="wp-element-caption">Envis vid seger på Solvalla under Elitloppshelgen i år. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Bland syskonen finns femårige topphästen <strong>Envis</strong> (1.267.881 kr), <strong>Buska Blyg</strong> (1.188.000 kr), <strong>Crussi Dull</strong> (994.393 kr), <strong>Björli Odin</strong> (667.724 kr), <strong>Björli Mai</strong> (595.854 kr) och <strong>Friska Viljan</strong> (459.532), som startar i Svenskt Kallblodsderby i Östersund på onsdag.<br>I eftermiddag är hon högaktuell igen, som mamma till Robert Skoglund-tränade<strong> Gör Som Jag Vill</strong> (e. Järvsö Björn), som vunnit två av sju starter.</p>



<p><strong>Noterbart om mödrarna i Kriteriet:</strong></p>



<ul class="wp-block-list">
<li><strong>Grude Jenta</strong> (mor till Grude Erling) vann elva av tolv starter, däribland Derbystoet i både Sverige och Norge.</li>



<li><strong>Tangen Tina</strong> (mor till Tangen Martin) var tvåa i Stokriteriet i Norge och är mor till Oaksvinnaren Tangen Tone och Derbytrean Tangen Trygg.</li>



<li><strong>Alnatt Ö.K. </strong>(mor till Gargamel) är en dotter till Elitstoet Tripså.</li>



<li><strong>Karlängs Prima</strong> (mor till Holms Oden) har lämnat fjolårets dubbla Derbyfinalist Holms Pegasus.</li>



<li><strong>Hartveit Gulle</strong> (mor till Grisle Galant G.L.) har lämnat dubbelmiljonären Grisle Tore G.L.</li>



<li><strong>Mitt Hjärtas Lilja</strong> (mor till Mitt Hjärtas Hero) var finalist i Kriteriestoet och blev miljonärska.</li>



<li><strong>Raska Can</strong> (mor till Bazoo Can) var finalist i Kriteriestoet i både Sverige och Norge, samt Derbystoet och har lämnat dubbla klassiska finalisten Oss Can.</li>



<li><strong>Karelli</strong> (mor till Ellwis) var fyra i Oaks, finalist i Derbystoet och sprang in 1,1 miljoner. Mamma Kariba är Elitsto.</li>



<li><strong>Oppgårdens Smaragd</strong> (mor till Oppgårdens Brunte) är mor till Derbytvåan och flerfaldige storloppsfinalisten Oppgårdsdrängen.</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>



<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 fyra å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 Overvik Prinsen på 1.27,3a.</p>



<p><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">***</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">Kriteriestoet har några år kortare historia än Kriteriet, men dominanten bland tränarna är densamme. Jan-Olov Persson ståtar med sju tränarvinster sedan premiären 1999 och har tränat vinnarna av de tre senaste upplagorna: <strong>Dunungen, Lannem Stella</strong> och ifjol <strong>Majblomster</strong>.<br>Om det ska bli en fjärde raka titel i loppet är det upp till <strong>Eld Prinsessa</strong> (e. Tekno Odin) eller <strong>Hertiginnan Stöen</strong> (e. Tekno Odin), som är Perssons hopp i loppet.</p>



<p>Men det bjuds motstånd, både från Sverige och framför allt från Öystein Tjomsland. Norrmannen tränar nämligen halva finalfältet! Av hans sex finalister imponerade det sto han kör själv, <strong>Hå Lerke</strong> (e. Nordsjö Odin), allra mest i försöken med seger på 1.27,7a/2.140 meter, vilket var snabbare än vad någon av hingstarna och valackerna travade i fina uttagningslopp.</p>



<p>Notablet är att bakom loppets 25 vinnare står hela 19 olika tränare.</p>



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



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



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



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



<p class="has-drop-cap">Bergsåkertränaren Anders Wallin har firat de största framgångarna med varmblod genom åren, men nu har han ”bytt sida”. Blott fyra hästar finns i stallet, tre av dem är kallblod och inte vilka kallblod som helst. Segermaskinen <strong>Ulvsåsen</strong> (e. Åsajerven), fyraåriga <strong>Guli Stina</strong> (e. Briskeby Philip), som startar i Derbystoet på onsdag, och <strong>Björgen</strong> (e. Bork Odin), som vann sitt försök till Kriteriestoet tillsammans med Per Linderoth. Hittills har Björgen fyra segrar och ett andrapris på fem starter!</p>



<p>Wallin valde innerspår med sitt segervana sto i finalen.<br>– Att i sådana här lopp ska man hålla sig på innerspår. Björgen är riktigt kvick bakom bilen, så Per kan välja på att köra i spets eller släppa till en bra rygg. Kommer bara luckan kan hon avsluta vasst då hon har unik teknik. Vi ändrar inget i utrustningen, säger Anders Wallin.<br>– Det är tre-fyra hästar som sticker ut och hon är en av dem med tanke på sitt utgångsläge och att formen sitter där. Om vi skulle vinna? Det skulle vara enormt stort, hävdar Anders.</p>



<p><a href="https://sulkysport.se/fokus/wallins-klassiska-dubbel-unik-teknik/" target="_blank" rel="noreferrer noopener">––> Läs hela intervjun och Anders Wallins vägval att satsa kallt istället för varmt här!</a></p>



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



<p><strong>Dannero den 4 augusti</strong><br>2.140 meter autostart, förstapris: 500.000 kr:<br><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li>Björgen (e. Bork Odin) – Per Linderoth (Anders Wallin)</li>



<li>Hå Lerke (e. Nordsjö Odin) – Öystein Tjomsland</li>



<li>Stavre Maggan (e. Tekno Odin) – Vidar Tjomsland (Öystein Tjomsland)</li>



<li>M.P.Flora (e. Tekno Odin) – Ulf Ohlsson (Jerker Bjurman)</li>



<li>Eld Prinsessa (e. Tekno Odin) – Örjan Kihlström (Jan-Olov Persson)</li>



<li>Ängsflora (e. B.W.Modde) – Robert Skoglund</li>



<li>Hertiginnan Stöen (e. Tekno Odin) – Mats E Djuse (Jan-Olov Persson)</li>



<li>Kjempa Re (e. Ängsborken) – Henrik Svensson (Öystein Tjomsland)</li>



<li>Frk. Aase (e. Nordsjö Odin) – Tom Erik Solberg (Öystein Tjomsland)</li>



<li>Lille Rose G.L. (e. Bork Odin) – Magnus A Djuse (Öystein Tjomsland)</li>



<li>Bäcklös Tili (e. Horgen Tore) – Oskar Kylin Blom</li>



<li>Nord Jerva (e. Nordsjö Odin) – Jimmy Jonsson (Öystein Tjomsland)</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/2024/07/majblomster-617x333.jpg" alt="" class="wp-image-614013"/><figcaption class="wp-element-caption">Jan-Olov Persson-tränade Majblomster och Mats E Djuse vid segern i Derbystokval. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<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 <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>I Kriteriestoet är två svenskfödda vinnare snabbast i historien: <strong>Guli Anna</strong> vann tillsammans med Umåkertränaren Stefan Johansson för fem år sedan på 1.26,7a/2.140 meter och den tiden putsades med tre tiondelar av drottningen <strong>Majblomster</strong> förra året. 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><strong>Snabbaste vinnare i Kriteriestoet:</strong></p>



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



<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">***</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">Lennart Bäwerholms kallblodssto <strong>Eldsiri</strong> (e. Järvsöfaks) var en stjärna på banan – och en ännu större stjärna i avelsboxen. 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.</p>



<p>I avelsboxen är hon mamma till Kriterievinnarna och avelshingstarna <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>Hennes hopp idag är helsystern <strong>Eld Prinsessa</strong> i Kriteriestoet. Stoet har vunnit ett lopp, på Solänget i juli. Då som nu sitter Örjan Kihlstöm i vagnen.</p>



<p>18-åriga Eldsiri finns inte längre i Bäwerholms ägo. Stoet såldes till Menhammar Stuteri hösten 2022 och har där fått ytterligare två avkommor: ettårige <strong>Inkallad</strong> (e. Tekno Odin) och i år ett stoföl med Tangen Bork som pappa. </p>



<p><strong>Bland finalisterna i Kriteriestoet kan noteras noteras:</strong></p>



<ul class="wp-block-list">
<li><strong>Bäcklös Tili</strong> (e. Horgen Tore) är lillasyster till Kriterievinnaren Bäcklös Uriel (e. Smedheim Solan) och Kriterietvåan Bäcklös Faron (e. Järvsö Tore).</li>



<li>Frk.Aases mamma <strong>Aase</strong> (e. Åsajerven) vann Kriteriestoet på Dannero 2015. </li>



<li>Svenska Elitstoet <strong>Puma Jerva</strong> (e. Åsajerven) har firat stora framgångar efter sin egen lyckosamma tävlingskarriär. Hon är mor till dubbelmiljonärerna Ängsborken (e. Bork Odin) och Tekno Jerven (e. Tekno Jerven), där Ängsborken gjorde en enorm insats som trea i Kriteriet 2018 efter galopp, medan skada stoppade Tekno Jerven från start i Kriteriet. Ännu bättre gick det för dottern Tekno Jerva (e. Tekno Odin) som slutade tvåa i Stokriteriet på Bjerke.</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/2023/08/jerkerbjurman-617x333.jpg" alt="" class="wp-image-490613"/><figcaption class="wp-element-caption">Jerker Bjurman. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Skellefteåtränaren Jerker Bjurman har plockat fram ett flertal finalister till kallblodens klassiska unghästlopp. Till just Kriteriestoet på Dannero har han kvalat in sex hästar genom åren och nått ett flertal fina finalframgångar.<br>Bästa resultatet är andraplatsen för <strong>Katja Kiro</strong> (e. Lome Elden) 2013, men Jerker kan även skryta med tredjeplatser för <strong>Marre R.F.</strong> (e. Moe Svarten) 2017 och <strong>Holter Oda</strong> (e. Bork Odin) 2019.</p>



<p>Nu har Bjurman sin sjunde finalist i loppet. <strong>M.P.Flora</strong> (e. Tekno Odin) var trea i sitt försök och har fortfarande inte varit sämre än trea på sex starter i livet, där hälften slutat med seger.</p>



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



<p class="has-drop-cap">Ingen kusk har vunnit Kriteriestoet fler än två gånger, men fyra har tagit två segrar. Mats E Djuse har rattat vinnaren två år i rad.</p>



<p>En annan som lyckats med det är Ö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. </p>



<p><strong>Kuskar med två vinnare i Kriteriestoet:</strong></p>



<ul class="wp-block-list">
<li>Mats E Djuse – Lannem Stella 2022, Majblomster 2023</li>



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



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



<p class="has-drop-cap">Öystein Tjomsland och Jan-Olov Persson förstås, men ytterligare en tränare har kvalat in hästar till båda finalerna. Robert Skoglund kör egentränade <strong>Ängsflora</strong> (e. B.W.Modde) i Kriteriestoet, medan han lånar in Ulf Ohlsson bakom <strong>Gör Som Jag Vill</strong> (e. Järvsö Björn) i Kriteriet.</p>



<p>Roberts bortgångne pappa Anders har tränat en vinnare av Kriteriet. 1999 segrade <strong>Guli Gutten</strong> (e. Alm Silver) med Åke Svanstedt i sulkyn.</p>



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



<p class="has-drop-cap">Bakom varje häst står en skötare som känner travaren utan och innan och en som får extra fullt upp i eftermiddag är Anna-Karin Jonsson, som arbetar hos Öystein Tjomsland. Rutinerade Anna-Karin har nämligen tre finalister.</p>



<p>Dubbla finalister har även Vilde Abusdal från samma stall och Jenny Pettersson, som arbetar hos Jan-Olov Persson.</p>



<h2 class="wp-block-heading">Skötarna bakom hästarna i Kriteriet</h2>



<ul class="wp-block-list">
<li>Grude Erling – Christina Mikkelsen</li>



<li>Tangen Martin – Guro Mangseth</li>



<li>Gargamel –Silje Röste</li>



<li>Trollbackens Olov – Emelie Öberg</li>



<li>Gör Som Jag Vill – Johanna Frunck</li>



<li>Holms Oden – Annica Johansson Nordh</li>



<li>Grisle Galant G.L. – Anna-Karin Jonsson</li>



<li>Bäcklös Olle – Johanna Karlsson</li>



<li>Mitt Hjärtas Hero – Chloe Pettersson</li>



<li>Bazoo Can – Kai Pakola</li>



<li>Ellwis – Linda Wedin</li>



<li>Oppgårdens Brunte – Emelie Mood</li>
</ul>



<h2 class="wp-block-heading">Skötarna bakom hästarna i Kriteriestoet</h2>



<ul class="wp-block-list">
<li>Björgen – Anders Wallin</li>



<li>Hå Lerke – Vilde Abusdal</li>



<li>Stavre Maggan – Malin Christine Julseth</li>



<li>M.P.Flora – Ranja Burman</li>



<li>Eld Prinsessa – Jenny Pettersson</li>



<li>Ängsflora – Alice Sellstedt</li>



<li>Hertiginnan Stöen – Jenny Pettersson</li>



<li>Kjempa Re – Madelene Sjölander</li>



<li>Frk. Aase – Vilde Abusdal</li>



<li>Lille Rose G.L. – Anna-Karin Jonsson</li>



<li>Bäcklös Tili – Hanna Reiser</li>



<li>Nord Jerva – Anna-Karin Jonsson</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="if0md5Jzyd"><a href="https://sulkysport.se/fokus/wallins-klassiska-dubbel-unik-teknik/">Wallins klassiska dubbel: ”Unik teknik”</a></blockquote><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; visibility: hidden;" title="”Wallins klassiska dubbel: ”Unik teknik”” &ndash; Sulkysport" src="https://sulkysport.se/fokus/wallins-klassiska-dubbel-unik-teknik/embed/#?secret=7odoKcwxg6#?secret=if0md5Jzyd" data-secret="if0md5Jzyd" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe>
</div></figure>
