
<p class="has-drop-cap wp-block-paragraph">P<strong>hilip Ess, Nordsjö Odin, Havglimt, Tangen Bork</strong> och <strong>Tangen Minto</strong>. Fem år i rad har Öystein Tjomsland tränat vinnaren av Svenskt Kallblodsderby. Lägg därtill <strong>Tekno Odin</strong> 2012 och norrmannen är den mest framgångsrike tränaren i Derbyhistorien.</p>



<p class="wp-block-paragraph">I år kom han dock till uttagningsloppen med blott en häst. Fast inte vilken travare som helst! <strong>Bore Mikkel</strong> (e. Moe Odin) var kullens vinstrikaste travare och den ende treåring som passerade miljonvallen förra året när han vann tolv av 14 starter, plockade hem Biris Uppfödningslopp och en räcka lopp med sexsiffrig segercheck.<br>Förlusterna kom i de största loppen, han slutade femma efter galopp I Kriteriet på Dannero och tvåa bakom fortsatt obesegrade stallkamraten <strong>Brenne Borken</strong> (e. Tangen Bork) i norska upplagan. Den sistnämnde har travat 1.20,2ak i sommar, men varinte anmäld till de svenska klassikerna.</p>



<p class="wp-block-paragraph">I uttagningsloppet till Derbyt forsade Bore Mikkel med tränare Tjomsland i vagnen undan i lendingen sista rundan och landade på 1.23,1a/2.140 meter, en tid som i Derbyt tidigare bara straffats av trion Nordsjö Odin, Tangen Bork och <strong>Lannem Silje</strong>.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/07/tjomslandpersson-617x333.jpg" alt="" class="wp-image-473440"/><figcaption class="wp-element-caption">Öystein Tjomsland och Jan-Olov Persson vid spårlottningen till Kallblodsderbyt. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



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



<p class="wp-block-paragraph"><strong>2.140 meter autostart, förstapris 600.000 kr</strong><br><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li>Voje Nido (e. Åsajerven) – Lars Anvar Kolle (Jan Kristian Överdal)</li>



<li>Björs Balder (e. Smedheim Solan) – Per Linderoth (Jan-Olov Persson)</li>



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



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



<li>Brolin (e. Lome Brage) – Magnus A Djuse (Jan-Olov Persson)</li>



<li>Blomsterprinsen (e. Smedheim Solan) – Daniel Wäjersten (Jan-Olov Persson)</li>



<li>Järvsö Jop (e. Tekno Odin) – Ulf Ohlsson (Jan-Olov Persson)</li>



<li>Tekno Filur (e. Tekno Odin) – Kajsa Frick (Jan-Olov Persson)</li>



<li>Lakafanten (e. Will Prinsen) – Anders Lundström Wolden (Line Bjölgerud)</li>



<li>Holms Pegasus (e. B.W.Modde) – Tomas Pettersson (Alf Nordh)</li>



<li>Svarte Petter (e. B.W.Modde) – Torbjörn Jansson (Jan-Olov Persson)</li>



<li>Tern Odin (e. Tekno Odin) – Bo Landgren</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">De norskfödda travarna släpptes in i den svenska klassikern för första gången 1986 och sedan premiären är det stor övervikt Norge bland de 37 vinnare som korats: 28–9!<br>I årets startfält är det stor övervikt Sverige på förhand, då åtta av tolv finalister i Derbyt är födda här.</p>



<p class="wp-block-paragraph">Jan-Olov Persson tränar sju (!) av Derbyhästarna och Hagmyrentränaren har fyra triumfer i loppets historia. Förutom den svenskfödda trion nedan tränade han även norskfödde <strong>Stjerne Faks</strong> (e. Järvsöfaks), som vann 2007.</p>



<p class="wp-block-paragraph"><strong>De svenskfödda vinnarna sedan 1986:</strong></p>



<ul class="wp-block-list">
<li>1986 Lundick (e. Pavjol) – Alf Jonsson</li>



<li>1990 Erk Tron (e. Slogum Tron) – Åke Sundberg (Sven Abenius)</li>



<li>1993 Pålex K. (e. Pål Best) – Lars I Eriksson</li>



<li>1998 Rolex K. (e. Troll Jahn) – Lars I Eriksson</li>



<li>2003 Troll Kevin (e. Troll Jahn) – Jan Norberg</li>



<li>2004 Hallsta Lotus (e. Järvsöfaks) – Jan-Olov Persson</li>



<li>2008 Järvsöviking (e. Järvsöfaks) – Jan-Olov Persson</li>



<li>2011 Månprinsen A.M. (e. Svall Ivar) – Gunnar Melander</li>



<li>2017 Järvsö Pegasus (e. Tangen Scott) – Örjan Kihlström (Jan-Olov Persson)</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">Bara fem hästar har lyckats med att ta dubbeln Svenskt Kallblodskriterium och Svenskt Kallblodsderby sedan Kriteriet gjorde entré 1993.</p>



<p class="wp-block-paragraph">Jan-Olov Persson-tränade <strong>Brolin</strong> (e. Lome Brage) har chansen att kliva in i det celebra sällskapet sedan han tog en imponerande seger i Kriteriet på Dannero förra sommaren tillsammans med Mats E Djuse.<br>I Derbyt blir det kuskbyte, då Sveriges kuskchampion Magnus A Djuse ersätter storebror och kör sitt första Kallblodsderby. Två gånger körde han Brolin som treåring med en fjärdeplats som bästa resultat.</p>



<p class="wp-block-paragraph">Mats kör istället stallkamraten <strong>Envis</strong> (e. Lome Brage).</p>



<p class="wp-block-paragraph"><strong>Hästarna som tagit den klassiska dubbeln i Sverige:</strong></p>



<ul class="wp-block-list">
<li>1997-1998 Rolex K. (e. Troll Jahn) – Lars I Eriksson</li>



<li>2002-2003 Troll Kevin (e. Troll Jahn) – Jan Norberg</li>



<li>2004-2005 H.G.Balder (e. Lome Elden) – Vidar Hop (John Hasle)</li>



<li>2005-2006 Slått Eld (e. Lome Elden) – Jomar Blekkan</li>



<li>2013-2014 Lannem Silje (e. Åsajerven) – Tor Wollebaek (Ola M Skrugstad)</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/10/jantungenjarvsofaks-617x333.jpg" alt="" class="wp-image-117310"/><figcaption class="wp-element-caption">Jäntungen som föl bredvid Mollvi med Margareta Wallenius Kleberg på ryggen. Till höger Järvsöfaks. Foto Privat &#038; Mathias Hedlund</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Mellby Gård, Global Glide och Menhammar Stuteri har gjort sig mest kända i varmblodssammanhang, även om travdrottningen Jäntungen föddes just på Menhammar, då Margareta Wallenius Klebergs far Olof köpte Jäntungens mamma Mollvi 1947.<br><strong>Jäntungen</strong> (e. Solo) föddes 1949. Efter avslutad tävlingskarriär blev hon dräktig först vid 18 års ålder (!) och 1968 föddes Skarpjänta. Tre år senare kom <strong>Järvsöfaks</strong> mormors mor <strong>Steggjänta</strong> till världen.</p>



<p class="wp-block-paragraph">I fredagens Derby är Mellby Gård ägare bakom fjolårets Kriterievinnare <strong>Brolin</strong> (e. Lome Brage), medan Global Glide – som bland annat äger <strong>Stoletheshow</strong> och <strong>Ecurie</strong> <strong>D.</strong> – tillsammans med Menhammar är ägarna bakom <strong>Envis</strong> (e. Lome Brage), som dessutom är uppfödd av Menhammar Stuteri.</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/blomsterprinsen-617x333.jpg" alt="" class="wp-image-478671"/><figcaption class="wp-element-caption">Blomsterprinsen. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">I år har Sveriges bästa kallblodssto <strong>Stjärnblomster</strong> (e. B.W.Modde), 1.20,2ak*/3.590.893 kr, passerat <strong>Lundås Emelie</strong> och blivit vårt vinstrikaste sto genom tiderna. Detta efter en sensationell comeback på tävlingsbanan som sexåring.<br>Stjärnblomster vann Derbystoet och var tvåa i norska Stoderbyt som fyraåring 2018. Sedan togs hon till avel med retfulla 999.943 kronor på kontot och året efter födde hon en son.</p>



<p class="wp-block-paragraph">Denne son är <strong>Blomsterprinsen</strong> (e. Smedheim Solan), som redan ifjol visade framfötterna som finalist i både svenska och norska Kriteriet. Nu är han framme i sin tredje klassiker.</p>



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



<p class="has-drop-cap wp-block-paragraph">I Nina och Anders Jonssons regi var <strong>Myrs Hera</strong> (e. Bork Odin) en sagohäst som treåring och det räckte hela vägen till seger i Kriteriestoet på Dannero 2017 med Ulf Eriksson i vagnen.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/07/bjorsbalder-617x333.jpg" alt="" class="wp-image-473426"/><figcaption class="wp-element-caption">Jan-Olov Persson-tränade Björs Balder och Per Linderoth imponerade i första kvalet till Svenskt Kallblodsderby. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Lillebror <strong>Björs Balder</strong> (e. Smedheim Solan) var också med under de treåriga kallblodens största dag i Sverige när han ifjol slutade fyra i Svenskt Kallblodskriterium.<br>Efter en fin treåringsässong har Björs Balder hittat ytterligare växlar i år och tio starter har givit sju segrar och två andrapris! Björs Balder vann fyraåringarnas första storlopp för säsongen i Sverige, Sleipner Cup-finalen på Romme i maj, och har även hunnit med seger i heatlopp i Skellefteå, där han travade 1.26,5a och 1.24,8a samma kväll.<br>I Derbykvalet parkerade Per Linderoth utvändigt om ledande stallkamraten Brolin och Björs Balder gled undan till imponerande seger.</p>



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



<p class="has-drop-cap wp-block-paragraph">9 av tolv hästar i Derbyt är svensktränade och förutom Perssons sju, så kvalade Alf Nordhs <strong>Holm Pegasus</strong> (e. B.W.Modde) och Bo Landgrens <strong>Tern Odin</strong> (e. Tekno Odin) in till final.</p>



<p class="wp-block-paragraph">Holm Pegasus har de främsta meriterna av de båda och vann två lopp som treåring, samt slutade trea i Svensk Travsports Treåringsstjärna bakom Bore Mikkel och Envis.</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/07/siridonna-617x333.jpg" alt="" class="wp-image-473446"/><figcaption class="wp-element-caption">Siri Donna angav tonen för Öystein Tjomslands framgångar i Derbystokvalen när hon vann före stallkamraten Teknopuma. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Med storfavoriten i Svensk Kallblodsderby kanske Öystein Tjomsland lämnar fältet öppet i Derbystoet. Pyttsan! Fyra hästar i försöken. Fyra hästar till final och två segrar var resultaten under kvalkvällen i Östersund för två veckor sedan.<br>De båda försöksvinnarna har liknade bakgrund, nämligen närmast utan meriter från treåringssäsongen och enorm utveckling i år. </p>



<p class="wp-block-paragraph">Svenskfödda och svenskägda <strong>Siri Donna</strong> (e. Järvsö Tore) gjorde bara en start ifjol när hon debuterade först på luciadagen med en andraplats på 1.35,2 på Bergsåker. Förutom en paus under mars-april har det varit rena rama  segertåget i år och sex vinster finns bokförda.<br>Och klassiska segrar finns i blodet i Siri Donna, vars mamma <strong>Sirifaxa</strong> (e. Järvsöfaks), 1.28,8am/369.976 kr, var tvåa i Kriteriestoet och själv är syster till de klassiska vinnarna <strong>Tekno Eld</strong> (e. Tekno Odin) och <strong>Eld Rask</strong> (e. Tekno Odin).</p>



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



<p class="wp-block-paragraph"><strong>2.140 meter autostart, förstapris 600.000 kr</strong><br><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li>Siri Donna (e. Järvsö Tore) – Ulf Ohlsson (Öystein Tjomsland)</li>



<li>Vega N.O. (e. Åsajerven) – Öystein Tjomsland</li>



<li>Bol Lena (e. Horgen Tore) – Jan Roar Mjölneröd</li>



<li>Pave Faksa T.M. (e. Pave Faks) – Kristin Mogset (John Mogset)</li>



<li>Christina K. (e. Odd Herakles) – Eirik Höitomt (Thor Borg)</li>



<li>Åsa Mona (e. Bork Odin) – Ole Johan Östre (Merete Viksås)</li>



<li>Dhyana S. (B.W.Modde) – Robert Skoglund</li>



<li>Suså Ö.K. (e. Moe Odin) – Åsbjörn Tengsareid (Jens Kristian Brenne)</li>



<li>Teknopuma (e. Tekno Odin) – Jimmy Jonsson (Öystein Tjomsland)</li>



<li>Nelson Helen (e. Moe Odin) – Tom Erik Solberg (Öystein Tjomsland)</li>



<li>Kattelbo Kajsa (e. Järvsöviking) – Oskar Kylin Blom</li>



<li>Rina C.K. (e. Briskeby Rauen) – Per Oleg Midtfjeld (Sverre Hjörneröd)</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/2023/08/teknopuma-617x333.jpg" alt="" class="wp-image-478674"/><figcaption class="wp-element-caption">Teknopuma. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">På tal om framgångsrika hästar i stamtavla. Tjomslands andra svenskfödda finalist är <strong>Teknopuma</strong> (e. Tekno Odin), som var fyra i norska Stokriteriet förra året i regi Oskar J Andersson innan hon bytte tränare till Tjomland så sent som i slutet av april.<br>Teknopuma väntar fortfarande på karriärens första seger efter tio försök, men kusken Jimmy Jonsson har full koll på hennes syskon.</p>



<p class="wp-block-paragraph">Teknopuma är nämligen lillasyster till avelshingstarna och segermaskinerna <strong>Ängsborken</strong> (e. Bork Odin) och <strong>Tekno Jerven</strong> (e. Tekno Odin), som mestadels tränats av pappa Alf Jonsson och Jimmy har varit närmast ständig följeslagare i tävlingssulkyn.<br>Dessutom deläger och kör Jimmy storasyster <strong>Tekno Jerva</strong> (e. Tekno Odin), som var finalist i Derbystoet förra året och som treåring slutade tvåa i Stokriteriet på Bjerke.</p>



<p class="wp-block-paragraph">Supermamman bakom verket är <strong>Puma Jerva</strong> (e. Åsajerven), 1.24,8k/1.201.838 kr, som tränades hela karriären av Alf Jonsson.</p>



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



<p class="has-drop-cap wp-block-paragraph">Robert Skoglund och Oskar Kylin Blom är två andra svenska hopp i loppet som domineras stort av norrmännen. </p>



<p class="wp-block-paragraph">Skoglunds <strong>Dhyana S. </strong>(e. B.W.Modde) tog sin största av två segrar i ett treåringslopp för ston förra hösten, medan Kylin Bloms <strong>Kattelbo Kajsa</strong> (e. Järvsöviking) fick sitt stora genombrott när hon vann stoavdelningen i fyraåringsserien Sleipner Cup i maj.</p>



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



<p class="wp-block-paragraph">104 gånger pengarna blev vinnaroddset!<br>– Man kan inte säga att man tror på chans när man står i över 100 gånger pengarna, men jag sade till ägarna efter förra starten att om jag inte kört galopp tror jag att vi hade slagit Lannem Stella då. Den gången var det autostart och nu stod vi 40 meter före, sade segerkusk och -tränare Oskar Kylin Blom efter triumfen. </p>



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



<p class="has-drop-cap wp-block-paragraph">J<strong>ärvsöfaks</strong> fick ge sig mot <strong>Rolex K. </strong>när han själv startade i Svenskt Kallblodsderby 1998, men han blev ju en vinnare på alla sätt efter den andraplatsen. Som i Derbysammanhang, där han är pappa till sex vinnare i historien. Tillsammans med Solo är den svenske stjärnan störst.<br>Av avelshingstarna med tre eller fler Derbysegrar som far har <strong>Moe Odin</strong> – som lämnade jordelivet i vintras – fortsatt avkommor på tävlingsbanan. I årets Derby en son till start och det är inte vem som helst utan förhandsfavoriten <strong>Bore Mikkel</strong>.</p>



<p class="wp-block-paragraph"><strong>Flest Derbysegrar som far:</strong></p>



<ul class="wp-block-list">
<li>Sex segrar: Järvsöfaks, Solo</li>



<li>Fem segrar: Pavin, Steggbest</li>



<li>Fyra segrar: Remin</li>



<li>Tre segrar: Alm Rigel, Elding, Moe Odin, Skarphedin, Troll Jahn</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">B<strong>ork Odin</strong> har varit pappa till de två senaste Derbyvinnarna <strong>Tangen Bork</strong> och <strong>Tangen Minto</strong>, men saknar avkomma i årets Derby. Däremot finns tre tidigare vinnande fäder representerade av totalt sju avelshingstar med avkommor i startfältet.<br>Nämnde Moe Odin, Tekno Odin och Åsajerven har alla blivit pappor till svenska Derbyvinnare tidigare.</p>



<p class="wp-block-paragraph"><strong>Så här har det gått för avelshingstarna:</strong><br><em>Avelshingst (antal 2023) – Tidigare finalister – Bästa placeringar</em></p>



<ul class="wp-block-list">
<li><strong>Tekno Odin</strong> (3) – 9 – Nordsjö Odin (etta 2019), Tekno Eld (tvåa 2018), Oppgårdsdrängen (tvåa 2021)</li>



<li><strong>B.W.Modde</strong> (2) – 2 – ingen topp tre</li>



<li><strong>Lome Brage</strong> (2) – 1 – ingen topp tre</li>



<li><strong>Smedheim Solan</strong> (2) – 1 – ingen topp tre</li>



<li><strong>Moe Odin</strong> (1) –  34– Särpefanten (etta 2009), Tekno Odin (etta 2012), Havglimt (etta 2020), Bork Odin (tvåa 2009), Eikdölen (tvåa 2012), Odd Herakles (tvåa 2014), Grisleprinsen G.L. (tvåa 2020), Mel Odin (trea 2010), Sjö Odin (trea 2015), Bol Odin (trea 2017), Brenne Banker (trea 2018)</li>



<li><strong>Will Prinsen</strong> (1) – inga startande</li>



<li><strong>Åsajerven</strong> (1) – 8 – Lannem Silje (etta 2014), Myr Faksen (tvåa 2012), Våler Nikolai (tvåa 2019), Fjord Jerven (trea 2014)</li>
</ul>



<p class="has-drop-cap 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/07/pavefaksat.m.kmogsetjpg-617x333.jpg" alt="" class="wp-image-476304"/><figcaption class="wp-element-caption">Pave Faksa T.M. visade fin form när hon gjorde comeback efter griffelbensbrott och slutade tvåa i sitt försök till Derbystoet. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Förra året spräckte Tekno Odin segernollan som vinnande fadershingst i Derbystoet när Öystein Tjomslands <strong>Nordsjö Anna</strong> vann före en annan Tekno Odin-dotter <strong>Sjö Perla</strong>. Då var han pappa till fem av tolv finalister i Derbystoet – i år har han faktiskt bara en finalist i svenskfödda Teknopuma.<br>Förutom Tekno Odin har fyra av årets pappor har tidigare haft vinnare: Bork Odin har dessutom två vinnare, medan Moe Odin – ensam om två startande avkommor i Derbystoet i år – Åsajerven och svenskfödde B.W.Modde har en vinst vardera.</p>



<p class="wp-block-paragraph">Hela elva (!) olika avelshingstar har avkommor i Derbystoet och för fyra av dessa är det premiär i loppet. En av dem, <strong>Pave Faks</strong> (e. Järvsöfaks), har sin första kull bestående av två fyraåringar, där alltså fjolårets norska Oaksvinnare <strong>Pave Faksa T.M.</strong> är en av dem.</p>



<p class="wp-block-paragraph"><strong>Så här har det gått för avelshingstarna:</strong><br><em>Avelshingst (antal 2023) – Tidigare finalister – Bästa placeringar</em></p>



<ul class="wp-block-list">
<li><strong>Moe Odin</strong> (2) – 19 – B.W.Gullis (etta 2016), Rönningholms Moa (tvåa 2008), Järvsö Nettan (trea 2009), Odile Kiro (trea 2013), Euforia (trea 2015)</li>



<li><strong>Bork Odin</strong> (1) – 20 – Glade Tider (etta 2019), Norheim Borka (etta 2020), Tante Ragnhild (tvåa 2015), Brenne Berna (tvåa 2020), Hopp Karoline (tvåa 2021), Lyn Rappa (trea 2014), Tangen Tone (trea 2022)</li>



<li><strong>Briskeby Rauen</strong> (1) – inga startande</li>



<li><strong>B.W.Modde</strong> (1) – 3 – Stjärnblomster (etta 2018)</li>



<li><strong>Horgen Tore</strong> (1) – 5 – ingen topp tre</li>



<li><strong>Järvsö Tore</strong> (1) – inga startande</li>



<li><strong>Järvsöviking</strong> (1) – 10 – Hulte Nova (tvåa 2013), Åsrud Vilja (tvåa 2014), Viggjerva (tvåa 2017)</li>



<li><strong>Odd Herakles</strong> (1) – inga startande</li>



<li><strong>Pave Faks</strong> (1) – inga startande</li>



<li><strong>Tekno Odin</strong> (1) – 14 – Nordsjö Anna (etta 2022), Brenne Blesa (tvåa 2019), Sjö Perla (tvåa 2022), Eldoda (trea 2019), Malifika (trea 2021)</li>



<li><strong>Åsajerven</strong> (1) – 9 – Patsi (etta 2015), Aase (trea 2016)</li>
</ul>
