
<p class="has-drop-cap"><strong>Philip Ess</strong> (2018), <strong>Nordsjö Odin</strong> (2019), <strong>Havglimt</strong> (2020), <strong>Tangen Bork</strong> (2021), <strong>Tangen Minto</strong> (2022), <strong>Bore Mikkel</strong> (2023), <strong>Frivoll Gorm</strong> (2024) och <strong>Tangen Martin</strong> (2025). Där har ni Öystein Tjomsland osannolika segersvit i Svenskt Kallblodsderby.</p>



<p>När han på lördagen jagar nionde raka tränarsegern i kallblodens klassiker har har fyra kort att spela med. De största förhoppningarna knyts till försöksvinnaren <strong>Tangen Nils</strong> (e. Bork Odin), som själv är lillebror till 2022 års Derbyvinnare Tangen Minto. Tangen Nils tog topplaceringar i treåringssäsongens storlopp utan att få sätta nosen först i Kriterierna eller Biris Uppfödningslopp, men nu andras både tränare Tjomsland och körsven Tom Erik Solberg optimism.<br>– Det är en väldigt fin häst. Han är lite stor, men känns lättare än han ser ut när man kör honom och det flyter bra för honom. Det fanns krafter kvar nu, sade Tom Erik Solberg efter segern i försöket.</p>



<p>Tjomsland kör själv den minst meriterade och rutinerade i stallets kvartett, <strong>Hallogubben</strong> (e. Grisle Odin G.L.). Fast denne har Derbyvinnarblod i ådrorna. Pappa <strong>Grisle Odin G.L. </strong>vann norska Derbyt 2020, medan mamma <strong>Patsi</strong> bland annat tog hem Derbystoet 2015.<br>Tjomsland har även segrat med <strong>Tekno Odin </strong>(e. Moe Odin) 2012 och är med nio triumfer överlägsen i Derbyhistorien bland tränarna. Tom Erik Solberg har kört fyra av av Tjomslands vinnare i Derbyt, medan tränaren själv styrt fem vinnare.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/07/tangennils-617x333.jpg" alt="" class="wp-image-879097"/><figcaption class="wp-element-caption">Öystein Tjomsland-tränade Tangen Nils och Tom Erik Solberg. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



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



<p>2.140 meter autostart, Östersund 8 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>Tangen Nils</strong> (e. Bork Odin) – Tom Erik Solberg (Öystein Tjomsland)</li>



<li><strong>Py Viking</strong> (e. Pydin) – Tomas Pettersson (Niclas Torstemo)</li>



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



<li><strong>Lannem Pär</strong> (e. Tekno Odin) – Örjan Kihlström (Öystein Tjomsland)</li>



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



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



<li><strong>Guli Kasper</strong> (e. Tekno Odin) – Marcus Lilius (Jan-Olov Persson)</li>



<li><strong>Järvsö Robert</strong> (e. Järvsö Elling) – Mats E Djuse (Jan-Olov Persson)</li>



<li><strong>Skeie Loke</strong> (e. Grisle Odin G.L.) – Rikard N Skoglund (Öystein Tjomsland)</li>



<li><strong>Hallogubben</strong> (e. Grisle Odin G.L.) – Öystein Tjomsland</li>



<li><strong>Oddfax</strong> (e. Odd Herakles) – Oskar 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/2026/07/angsrask-617x333.jpg" alt="" class="wp-image-879119"/><figcaption class="wp-element-caption">Robert Skoglund-tränade Ängsrask och Ulf Ohlsson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">På prispallen i båda Kriterierna förra året kom Sveriges bästa hingst, Robert Skoglund-tränade <strong>Ängsrask</strong> (e. Bork Odin). Han slutade tvåa i svenska och trea i norska Kriteriet och vann fem av elva starter som treåring.</p>



<p>Årets säsong innehåller fyra segrar och ett andrapris på fem försök och av insatsen vid segern i Derbybkvalet från ledningen ser Skoglund ut att ha prickat formen.</p>



<p>Förra året kvalade Bergsåkertränaren in Gör Som Jag Vill (e. Järvsö Björn), som vunnit Kriteriet året före. Då blev det en femteplats i Derbyt, men nu finns hopp om bättre placering.<br>– Han är så finkörd den här och jag kunde köra som jag ville i ledningen. Jag tyckte att värsta hotet satt i rygg och det var rätt lugn fart. Jag lät honom gå undan sista 100 meterna eftersom det var ett tag sedan han startade, sade Ulf Ohlsson efter den imponerande försökssegern.</p>



<p>Hästens mamma Ängsrappa (e. Elding) är utsedd till Elitsto och är – förutom till Ängsrask – mamma till ytterligare två miljonärer i stona Ängsthea och Ängspuma.</p>



<p><strong><a href="https://sulkysport.se/kallblodsderbyt-blir-det-bennys-sulky-som-vinner/" target="_blank" rel="noreferrer noopener">Ängsrask ägs av mångårige sulkybyggaren Benny Grafström – läs intervjun med Benny här!</a></strong></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/08/pyviking-617x333.jpg" alt="" class="wp-image-883528"/><figcaption class="wp-element-caption">Py Viking. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">P<strong>ydin </strong>(e. Moe Odin), 1.20,1ak*/3.421.594 kronor, har en enda avkomma född 2022 och totalt sju avkommor födda 2019-2022. Pydin är uppfödd och ägd av jämtlandsprofilen Bo Torstemo som under 40-talet år som uppfödare gjort stora avtryck.</p>



<p>1986 var starten på Bo Torstemos uppfödargärning när han köpte <strong>Pyla Best</strong> (född 1974 e. Steggbest-Pylana B.) som fölsto. Från henne har det kommit otaliga topphästar och den främste är Pydin. Än så länge är bäst att tillägga. </p>



<p>Pydin tränades av sonen Niclas med proffslicens på Hagmyren, vann vann 26 lopp och slutade tvåa i norska Derbyt 2016. I dennes son <strong>Py Viking</strong> har Torstemos ett nytt Derbyhopp. Sju pallplatser på nio starter var resultatet för Py Vikings fina treåringssäsong, som kröntes med segern i Jämtländskt Uppfödningslopp – och det var en stor triumf för Bo Torstemo.<br>Det var första gången på 45 år som det blev en jämtlandsfödd vinnare i treåringsloppet som körts sedan 1931.<br>– Det är riktigt hemmagjort: pappa, mamma, mormor, farmor och mormors mor, sade Bo Torstemo i vinnarcirkeln efter vinsten.</p>



<p>Nu väntar karriärens största uppgift hittills i Svenskt Kallblodsderby, där Py Viking tillsammans med Tomas Pettersson spurtade till vinst i försöket.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2026/08/botorstemoavelsnummer2026.pdf" target="_blank" rel="noreferrer noopener">Läs Sulkysports långa intervju med Bo Torstemo om hans liv med hästar från Avelsnumret i mars här!</a></p>



<h2 class="wp-block-heading">Uppfödare/hästägare i Svenskt Kallblodsderby</h2>



<p><em>Häst – Uppfödare – Hästägare</em></p>



<ol class="wp-block-list">
<li><strong>Ängsrask</strong> – Jenny Nyström &#038; Daniel Olsson – Benny Grafström, Sundsvall</li>



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



<li><strong>Py Viking</strong> – Bo Torstemo, Hackås – Bo Torstemo, Hackås</li>



<li><strong>Bato Prinsen</strong> – Barbro &#038; Tomas Hennersson – Ofcourse KB, Kovland</li>



<li><strong>Lannem Pär</strong> – Ola M Skrugstad, Norge – Björnar Högseth, Norge</li>



<li><strong>Skinnes Storm</strong> – Lovise Mohaugen &#038; Knut Andresen, Norge – Glenn Arne Githmark, Norge</li>



<li><strong>Grude Nils</strong> – Martin Hove, Norge – Martin Hove, Norge</li>



<li><strong>Guli Kasper</strong> – F Andersson &#038; HB Anderssons Hästar – Ofcourse KB, Kovland</li>



<li><strong>Järvsö Robert</strong> – Jan-Olov Persson, Hudiksvall – Easy KB, Uppsala</li>



<li><strong>Skeie Loke</strong> – Henning Skeie &#038; Ove Bakkevold Reime, Norge – N Munkhaugen Holding AS, Norge</li>



<li><strong>Hallogubben</strong> – Öystein Tjomsland, Norge – Tore Gard, Norge</li>



<li><strong>Oddfax</strong> – Anders &#038; Anette Carlsson – Easy KB, Uppsala</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/2026/08/jarvsorobert-617x333.jpg" alt="" class="wp-image-883131"/><figcaption class="wp-element-caption">Järvsö Robert och Jan-Olov Persson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Jan-Olov Persson har fyra triumfer i loppets historia. Förutom den svenskfödda trion <strong>Hallsta Lotus</strong> (e. Järvsöfaks), <strong>Järvsöviking</strong> (e. Järvsöfaks) och <strong>Järvsö Pegasus</strong> (e. Tangen Scott) tränade han även norskfödde <strong>Stjerne Faks</strong> (e. Järvsöfaks), som vann 2007.<br>Nu har det gått nio år sedan en Persson-häst senast tog hem svenska Derbyt, Järvsö Pegasus 2017, och Hagmyrentränaren rustar med en duo i årets final.</p>



<p><strong>Järvsö Robert</strong> (e. Järvsö Elling) visade tidig talang som treåring, men efter tre starter och lika många segrar tog säsongen abrupt slut. I år har han kommit tillbaka på bra sätt och inte varit sämre än tvåa på åtta starter. </p>



<p>Pappa <strong>Järvsö Elling</strong> (e. Horgen Tore), 1.23,2k/897.579 kr, var duktig som unghäst och slutade fyra i både svenska och norska Derbyt. Som femåring betäckte han lite och fick tre avkommor 2022, men det blev hans enda. Han dog samma år.<br>Alla tre har kommit till start och vunnit lopp. De övriga två är <strong>Mana Erling</strong>, 1.31,9k/84.500 kr, och <strong>Järvsö Hans</strong>, 1.34,1m/65.800 kr.</p>



<p>Perssons andra Derbyhäst <strong>Guli Kasper</strong> (e. Tekno Odin) är lillebror till <strong>Tekno Filur</strong>, Derbyfinalist 2023.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/07/pyviking-617x333.jpg" alt="" class="wp-image-879109"/><figcaption class="wp-element-caption">Niclas Torstemo-tränade Py Viking och Tomas Pettersson höll undan för Stefan Edins Bato Prinsen i försöket. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Dannerotränaren Stefan Edin har de senaste sex åren firat framgångar med avkommor till <strong>Järvsö Mosterkarin</strong> (e. Järvsöviking). Stoet fick sex föl, fem av dem har startat och bäst i klassen är duon <strong>Bato Tösen</strong> (625.800 kr) och <strong>Bato Odina</strong> (562.500 kr), men hennes främsta hingst <strong>Bato Prinsen</strong> (e. Bork Odin) står inte långt efter med 459.500 kronor på kontot och en biljett i Svenskt Kallblodsderby.</p>



<p>Bato Prinsen var finalist i Kriteriet på Dannero förra året (oplacerad i finalen) och i juni tog han karriärens största seger i finalen av fyraåringsserien Sleipner Cup på Romme. I Derbykvalet var han inte stort slagen av Py Viking som tvåa.</p>



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



<p class="has-drop-cap"><strong>Nordsjö Odin</strong> (e. Tekno Odin) är tidernas snabbaste vinnare av Svenskt Kallblodsderby. För sju år sedan stormade han fram på 1.22,0a/2.140 meter tillsammans med sin tränare Öystein Tjomsland.</p>



<p>Nordsjö Odin saknar avkomma i årets Derbyfält, men hans pappa <strong>Tekno Odin</strong> är med i matchen med två söner i finalen: <strong>Lannem Pär </strong>och<strong> Guli Kasper</strong>. </p>



<p><strong>De snabbaste vinnarna i Svenskt Kallblodsderby:</strong></p>



<ul class="wp-block-list">
<li>1.22,0 – <strong>Nordsjö Odin</strong> (e. Tekno Odin – Nordli Vinni), 2019, Öystein Tjomsland</li>



<li>1.22,6 – <strong>Tangen Bork</strong> (e. Bork Odin – Tangen Stöva), 2021, Tom Erik Solberg</li>



<li>1.22,9 – <strong>Tekno Odin</strong> (e. Moe Odin – Lyana), 2012, Öystein Tjomsland</li>



<li>1.23,1 – <strong>Lannem Silje</strong> (e. Åsajerven – Lannem Sjura), 2014, Tor Wollebaek</li>



<li>1.23,1 – <strong>Bore Mikkel</strong> (e. Moe Odin – Ridder Rosa), 2023, Öystein Tjomsland</li>



<li>1.23,5 – <strong>Tangen Minto</strong> (e. Bork Odin – Mangen Mina), 2022, Tom Erik Solberg</li>



<li>1.24,0 – <strong>Philip Ess</strong> (e. Briskeby Philip – Tangen Pia), 2019, Öystein Tjomsland</li>



<li>1.24,0 – <strong>Havglimt</strong> (e. Moe Odin – Sjefslill), 1.24,0, 2020, Öystein Tjomsland</li>
</ul>



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



<p class="has-drop-cap">L<strong>annem Silje </strong>(e. Åsajerven), 1.18,8ak*/6.881.134 nkr, är troligen det sista stoet att vinna Svenskt Kallblodsderby, sedan prissummorna jämställts mellan könen och båda finalerna bjuder 600.000 kronor till vinnarna. Hennes segertid 1.23,1a/2.140 meter står sig fortsatt stark i listan ovan.</p>



<p>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>Förstfödda <strong>Lannem Stina</strong> (e. Dotterud Teddy) kom däremot aldrig till start och har istället fått fyra avkommor. Först ut var hingsten <strong>Lannem Pär</strong> (e. Tekno Odin), som via andraplatsen bakom Ängsrask kvalade in till finalen. Öystein Tjomsland tog över träningen den här säsongen, sedan sedan Lannem Pär tävlat för Anders Lundström Wolden som treåring.<br>Lannem Stinas andra avkomma, treårige <strong>Lannem Pål</strong> (e. Tekno Odin), inledde med tre raka segrar och var finalist i Svenskt Kallblodskriterium i söndags, men slutade oplacerad.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2018/01/jrvsfaksihagen-617x288.jpg" alt="Sulkysport, Travsport, Trav, Häst, Järvsöfaks" class="wp-image-17802"/><figcaption class="wp-element-caption">Järvsöfaks. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Järvsöfaks fick ge sig mot Rolex K. 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.</p>



<p>Järvsöfaks sista avkommor föddes 2015 och hans blod lever i högst grad vidare. I årets Derbyfält bär hälften av tolv hästar hans blod. Han är morfar till Oddfax, morfars far till Py Viking, Bato Prinsen och Hallogubben, mormors farfar till Lannem Pär och morfars morfar till Järvsö Robert.</p>



<p><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: Moe Odin, Remin</li>



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



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



<p class="has-drop-cap">1986 släpptes de norskfödda travarna in i den svenska klassikern för första gången och sedan premiären är det stor övervikt Norge bland de 40 vinnare som korats: 31–9!</p>



<p>I årets startfält är det jämnt fördelat mellan länderna. </p>



<p><strong>De svenskfödda vinnarna sedan 1986:</strong></p>



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



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



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



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



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



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



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



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



<li>2017 <strong>Järvsö Pegasus</strong> (e. Tangen Scott) – Örjan Kihlström (Jan-Olov Persson)</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/2026/08/grudenils-617x333.jpg" alt="" class="wp-image-883535"/><figcaption class="wp-element-caption">Kjetil Djöseland-tränade Grude Nils och Åsbjörn Tengsareid. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Bara fem hästar har lyckats med att ta dubbeln Svenskt Kallblodskriterium och Svenskt Kallblodsderby sedan Kriteriet gjorde entré 1993. Ska det ske i år är det upp till 2022-kullens givne kung som treåring: norske <strong>Grude Nils</strong> (e. Grisle Odin G.L.). Kjetil Djöselands travare vann Kriteriet i både Sverige och Norge och vann dessutom Biris Uppfödningslopp under treåringssäsongen.</p>



<p>I år har det hackat i maskineriet och i Derbykvalet räddade han finalplatsen som trea efter nästan tre månaders tävlingsuppehåll.<br>– Han var sjuk på Forus (i början av maj, reds. anm.) och fick en penecillinkur. Det gjorde att han missade Prinsessan Madeleines Pokal, så det har inte varit någon optimal uppladdning. Han ska gå framåt med loppet i kroppen och det är klart att han kan vinna finalen. Jag blev inte skrämd av de andra hästarna, säger Kjetil Djöseland till Trav- og Galopp-Nytt.</p>



<p>Djöseland sitter själv i vagnen i finalen – Åsbjörn Tengareid körde i försöket och i norska Kriteriet förra året – och Forustränaren jagar första svenska Derbysegern. Ifjol vann han Derbyt i Norge med <strong>Gigant Tider</strong> (e. Norheim Svenn).</p>



<p><strong>Hästarna som tagit den klassiska dubbeln i Sverige:</strong></p>



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



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



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



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



<li>2013-2014 <strong>Lannem Silje</strong> (e. Åsajerven) – Tor Wollebaek (Ola M Skrugstad)</li>
</ul>



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



<p class="has-drop-cap">En båttur till Mariehamn är ingen vanlig uppladdning inför Svenskt Kallblodsderby. Precis så gjorde Oskar Kylin Blom med <strong>Oddfax</strong> (e. Odd Herakles) i början av juli för att genrepa inför Derbykvalen. Resultatet blev en andraplats på det röda gruset på Åland bakom finske tolvåringen Midas (e. Erikasson) och fjärdeplatsen i Derbykvalet vilket gav platsen i finalen.</p>



<p>– Oddfax gjorde det bra i sitt försök då han avslutade väldigt starkt, det var ett av hans bästa lopp i livet. Det blir så klart tufft med tanke på utgångsläget och det gäller att försöka plocka med sig så bra pengar som möjligt. Det blir rycktussar för första gången, han svarade bra på det i måndagens träningsjobb, 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/2026/07/tekla-617x333.jpg" alt="" class="wp-image-879110"/><figcaption class="wp-element-caption">Tekla och Sandra Eriksson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Av åtta klassiska unghästfinaler förra året blev det norsk seger i sju. Den enda som kunde bryta den norska domninansen var Sandra Erikssons racer <strong>Tekla</strong> (e. Tekno Odin), som tog hem Stokriteriet på Bjerke. Det var höjdpunkten under en fin treåringssäsong som även innehöll fjärdeplatsen i Kriteriestoet på Dannero.</p>



<p>Direkt efter Bjerkevinsten fanns ett mål i sikte: Derbystoet i Östersund. Nu hon Tekla och Sandra framme vid målet och uttagningsloppet lämnade ingen övrigt att önska när Tekla i bekväm stil gled undan till lätt seger i en snabb avslutning på kvickaste försökstiden 1.27,0a/2.140 meter.<br>– Vi har siktat mot det här sedan förra året och hon har fått möta äldre hästar i vinter när det inte funnits andra lopp. Hon är vacker som en tavla och snabb som en Ferrari, sade Sandra Eriksson efter den segern.</p>



<p>Matchningsmässigt har Sandra fått söka motstånd från äldre hästar i vår och sommar. Ett fyraårimngslopp för ston i Sleipner Cup-serien var utskrivet i norra Sverige och dit anmäldes en häst: Tekla.</p>



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



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



<ol class="wp-block-list">
<li><strong>Mjölner Tyra</strong> (e. Ängsborken) – Jan Roar Mjölneröd</li>



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



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



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



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



<li><strong>Grevinnan Stöen</strong> (e. Tekno Odin) – Jan-Olov Persson</li>



<li><strong>Sjö Lilja</strong> (e. Bork Odin) – Magnus A Djuse (Jan Roar Mjölneröd)</li>



<li><strong>Mamelukk Ö.K.</strong> (e. Grisle Odin G.L.) – Robert Skoglund</li>



<li><strong>Skeie Ylva</strong> (e. Bork Odin) – Öystein Tjomsland</li>



<li><strong>Jonases Lykka</strong> (e. Tekno Odin) – Wiktor Kylin-Blom</li>



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



<li><strong>Järvsö Josefin</strong> (e. Smedheim Solan) – Marcus Lilius (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/2026/08/angsmolly-617x333.jpg" alt="" class="wp-image-883540"/><figcaption class="wp-element-caption">Ängsmolly och Kajsa Frick. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Kajsa Frick har firat framgångar med unga kallblod genom åren och då gärna på stosidan. En ny topphäst har hon i årets vinstrikaste sto i kullen, <strong>Ängsmolly</strong> (e. Norheim Faksen). Stoet debuterade redan i februari förra året och gjorde en gedigen treåringssäsong, där finalplats i Kriteriestoet fanns på meritlistan.</p>



<p>I år har hon tagit nya kliv och vunnit fyra av åtta starter. Den stora fullträffen kom i Sleipner Cup-finalen för ston i juni, där hon från dubbla tillägg och efter en resa utan rygg hela vägen bara var tuffast och vann på strålande sätt.<br>– Kan vi hålla den här formen så ska det bli roligt i Derbyt, sade Kajsa Frick efter segern.</p>



<p>Det har Kajsa och Ängsmolly lyckats med!</p>



<p>Ängsmolly har sina papper i ordning och hon är undan <strong>Granetta </strong>(e. Tekno Odin), 1.21,0ak/1.413.459 kr, som var en topphäst på banan och är fortsatt innehavare av två svenska rekord för femåriga ston.<br>Alf Jonsson tränade stoet som tog största segern i Erik Perssons Minne i Årjäng som femåring tillsammans med Jimmy Jonsson. Totalt gjorde Granetta 69 starter (18-6-4) innan avelsboxen väntade och där är Ängsmolly första avkomman.</p>



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



<p class="has-drop-cap">T<strong>ekla</strong> (e. Tekno Odin) är ägd och uppfödd av Countess AB och bakom namnet döljer sig paret Peter och Camilla Vikström från Norra Sunderbyn, mellan Boden och Luleå.</p>



<p>Vikströms har sitt främsta kallblod i tioårige hingsten <strong>Gorm</strong> (e. Dotterud Teddy), 1.20,8ak/1.951.481 kr. Denne tävlade med framgång hos Svante Båth och kom till Sandra sommaren 2023. Gorm avslutade karriären i somras efter 55 starter (20-11-4) och en av segrarna kom i högsta klassen i finska Uleåborg i Sandras regi. Nu är Gorm avelshingst på heltid.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/09/anitaadermalm-617x333.jpg" alt="" class="wp-image-768742"/><figcaption class="wp-element-caption">Anita Adermalm. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Teklas mamma är norskfödda unghäststjärnan <strong>Solvik Faksa</strong> (e. Voje Faks-Mona N.O.), 1.25,4am*/1.292.697 kr. Hon vann Stoderbyt i Norge, stoavdelningen i Biris Uppfödningslopp och slutade tvåa i Norskt Trav-Oaks innan karriären avslutades efter 22 starter (7-5-4).<br>Solvik Faksa såldes förra året till hårdsatsande Anita Adermalm, Arnemark. </p>



<h2 class="wp-block-heading">Uppfödare/hästägare i Derbystoet</h2>



<p><em>Häst – Uppfödare – Hästägare</em></p>



<ol class="wp-block-list">
<li><strong>Mjölner Tyra</strong> – Jan Roar Mjölneröd, Norge – Jan Roar Mjölneröd, Norge</li>



<li><strong>Tekla</strong> – Countess AB, Luleå – Countess AB, Luleå</li>



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



<li><strong>Ängsmolly</strong> – Lars-Erik &#038; Hans-Åke Karlsson – Stall Puma</li>



<li><strong>Kleppe Nissemor</strong> – Sigmund Öksnevad, Norge – Jan Roar Mjölneröd, Norge</li>



<li><strong>Grevinnan Stöen</strong> – Kristine Stöen Kivle, Norge – Stall Mr Winterbottom</li>



<li><strong>Sjö Lilja</strong> – Harald Wennesland, Norge – Kjell Skatvedt, Norge</li>



<li><strong>Mamelukk Ö.K.</strong> – Bernt Öksnevad, Norge – Wilda HB, Sundsvall</li>



<li><strong>Skeie Ylva</strong> – Henning Skeie, Norge – Rune Guttormsen &#038; Alf Laupsa, Norge</li>



<li><strong>Jonases Lykka</strong> – Conny &#038; Annika Kramme – Conny &#038; Annika Kramme</li>



<li><strong>Komnes Fina</strong> – Komnes Stall AB, Årjäng – Stall KAJ HB, Mölndal</li>



<li><strong>Järvsö Josefin</strong> – Jan-Olov Persson, Hudiksvall – Easy KB, Uppsala</li>
</ol>



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



<p class="has-drop-cap">I Derbystoet har de svenskfödda kallbloden stått sig starkare än i öppna klassen, i alla fall under loppets första decennium. Av 26 vinnare hittills sedan premiären 2000 är elva födda i Sverige. I Derbyt är siffrorna 31-9 i norsk favör sedan norrmännen släpptes in 1986.</p>



<p>Sedan Derbystoets förstapris uppgraderades rejält 2012 till 450.000 kronor har det dock blivit fyra svenska och tio norska vinster. Stona tävlar sedan 2022 om samma prispengar som hingstarna och valackerna, då vinnarna i båda klasserna får 600.000 vardera.</p>



<p><strong>Majblomster</strong> (e. Tekno Odin) bröt en lång norsk segersvit för två år sedan, men ifjol var det norskt i topp igen genom Öystein Tjomslands <strong>Hå Lerke</strong> (e. Nordsjö Odin).</p>



<p><strong>De svenskfödda vinnarna:</strong></p>



<ul class="wp-block-list">
<li>2001 <strong>Ellerina</strong> (e. Aaby Pil) – Åke Svanstedt (Lars-Åke Nordsten)</li>



<li>2003 <strong>Lykkeli</strong> (e. Lykke Gutten) – Åke Svanstedt (Tage H Eriksson)</li>



<li>2004 <strong>Karmine</strong> (e. Marine Svarten) – Ulf Ohlsson (Kent Hafstad)</li>



<li>2006 <strong>Styfs Maja</strong> (e. Schuvar) – Torsten Blomqvist (Sandra Nilsson)</li>



<li>2007 <strong>Perleann</strong> (e. Gullsvarten) – Ulf Ohlsson (Kent Hafstad)</li>



<li>2008 <strong>Pernilla Tabac</strong> (e. Lex Jon) – Tommy Eriksson</li>



<li>2009 <strong>Astra R.B.</strong> (e. Spikeld) – Rune Arvidsson (Marita Arvidsson)</li>



<li>2014 <strong>Bodbäckssiv</strong> (e. Briskeby Philip) – Jessica Lindgren</li>



<li>2016 <strong>B.W.Gullis</strong> (e. Moe Odin) – Örjan Kihlström (Thomas Lönn)</li>



<li>2018 <strong>Stjärnblomster</strong> (e. B.W.Modde) – Örjan Kihlström (Jan-Olov Persson)</li>



<li>2024 <strong>Majblomster</strong> (e. Tekno Odin) – Mats E Djuse (Jan-Olov Persson)</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/2026/07/skeieylva-617x333.jpg" alt="" class="wp-image-879096"/><figcaption class="wp-element-caption">Skeie Ylva och Öystein Tjimsland vann första försöket till Derbystoet. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Sverige har numerärt övertag i Derbystoet, där sju hästar tränas här och fem i Norge. När det gäller hästarnas födelseland har en utväxling skett där norskan <strong>Mamelukk Ö.K. </strong>(e. Grisle Odin G.L.) finns i Sverige hos Robert Skoglund, medan Jan Roar Mjölneröd tagit hem svenskregistrerade <strong>Mjölner Tyra</strong> (e. Ängsborken) till Norge.</p>



<p>Bakom den norska kvintetten döljer sig enbart två tränarnamn. Öystein Tjomsland med två finalister och Momarkentränaren Jan Roar Mjölneröd med en trio.</p>



<p>Tjomsland-ston vann två av tre försök genom <strong>Tangen Merete</strong> (e. Bork Odin) – tog livets första seger i elfte starten tillsammans med Tom Erik Solberg – och <strong>Skeie Ylva</strong> (e. Bork Odin), som körs av tränaren själv.</p>



<p>Jan Roar Mjölneröd har vunnit många stora kallblodslopp genom åren, men aldrig Derbystoet i Sverige. Ifjol var han mannen bakom två av de absolut främsta stona i kullen i Kleppe Nissemor (e. Norheim Svenn) och svenskfödda Mjölner Tyra (e. Ängsborken), som firade stora framgångar i treåringarnas stoklassiker. Duon kryddas med Sjö Lilja (e. Bork Odin).</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/08/grevinnanstoen-617x333.jpg" alt="" class="wp-image-883542"/><figcaption class="wp-element-caption">Grevinnan Stöen och Jan-Olov Persson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Öystein Tjomsland är den store dominanten i Derbystoets historia med sex vinster som tränare. Bakom honom finns det bara två tränare på två triumfer – en av dem är Jan-Olov Persson. Persson hoppar – precis som i försöket – själv upp i vagnen bakom <strong>Grevinnan Stöen</strong> (e. Tekno Odin), som är en av tre JOP-hästar i Derbystoets final.</p>



<p>Modern <strong>Vesle Fröken Stöen</strong> (e. Spikeld), 1.23,7am/1.451.358 kr, var själv ett riktigt toppsto på banan. Största segern kom i norska Stoderbyt 2014, men hon vann även stoavdelningen i Biris Uppfödningslopp och slutade tvåa i norska Oaks. Grevinnan Stöen är hennes sista avkomma.</p>



<p>Marcus Lilius kvalade in Perssons duo <strong>Järvsö Josefin</strong> (e. Smedheim Solan) och <strong>Komnes Fina</strong> (e. Tekno Odin), dör han kör Järvsö Josefin i finalen medan Mats E Djuse hoppar upp bakom Komnes Fina.</p>



<p>Den andre som tagit dubbla tränarvinster i Derbystoet är Östersundsamatören Kent Hafstad som gjorde det genom Karmine (e. Marine Svarten) 2004 och Perleann (e. Gullsvarten) 2007.</p>



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



<p class="has-drop-cap">Majblomsters segertid 1.24,3a/2.140 meter från 2024 är svenskt rekord för svenskfödda fyraåriga ston över medeldistans, men löpningsrekordet är några tiondelar vassare. Öystein Tjomsland styrde egentränade, norskfödda Patsi (e. Åsajerven) till vinst för nio år sedan på 1.23,9a. </p>



<p>Ingen av dagens finalister har travat under 1.26 över distansen hittills i karriären.</p>



<p><strong>Snabbaste vinnarna i Derbystoet:</strong></p>



<ul class="wp-block-list">
<li>1.23,9 – <strong>Patsi</strong> (e. Åsajerven – Tekno Pila), 2016, Öystein Tjomsland</li>



<li>1.24,3 – <strong>Majblomster</strong> (e. Tekno Odin – Järvsö Blomster), 2024, Mats E Djuse </li>



<li>1.25,2 – <strong>Norheim Borka</strong> (e. Bork Odin – Norheim Elle), 2020, Örjan Kihlström</li>



<li>1.25,3 – <strong>Vega N.O.</strong> (e. Åsajerven – Tema), 2023, Öystein Tjomsland</li>



<li>1.25,8 – <strong>Nordsjö Anna</strong> (e. Tekno Odin – Nordli Vinni), 2022, Öystein Tjomsland</li>



<li>1.26,0 – <strong>April Faxa</strong> (e. Smedheim Solan – Valle Faxa), 2021, Vidar Hop</li>



<li>1.26,2 – <strong>Glade Tider</strong> (e. Bork Odin – Gyldne Tider), 2019, Jomar Blekkan</li>



<li>1.26,4 – <strong>Brenne Blissi</strong> (e. Lome Elden – Brenne Järva), 2017, Åsbjörn Tengsareid</li>



<li>1.26,3 – <strong>Hå Lerke</strong> (e. Nordsjö Odin – Lotte Mollyn), 2025, Öystein Tjomsland</li>



<li>1.26,5 – <strong>Stjärnblomster</strong> (e. B.W.Modde – Järvsö Blomster), 2018, Örjan Kihlström</li>
</ul>



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



<p class="has-drop-cap">Öystein Tjomsland är  den mest framgångsrike kusken med fem segrar. Örjan Kihlström följer med tre vinster (<strong>B.W.Gullis, Stjärnblomster</strong> och <strong>Norheim Borka</strong>), medan Åke Svanstedt och Ulf Ohlsson vunnit två gånger vardera.</p>



<p>Åkes segerhästar är <strong>Ellerina</strong> och <strong>Lykkeli</strong>, medan Ohlsson segrade med Kent Hafstads duo <strong>Karmine</strong> och <strong>Perleann</strong>.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/08/jonaseslykka-617x333.jpg" alt="" class="wp-image-883545"/><figcaption class="wp-element-caption">Jonases Lykka och Wiktor Kylin-Blom. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap"><strong>Jonases Lykka</strong> (e. Tekno Odin) hade andraplatsen på gaffeln i Kriteriestoet förra året, då hopn slog på en galopp för sin tränare Jan-Olov Åberg. Sedan bytte hon regi till Billy Svedberg, där hon fanns ett halvår utan att komma till start, innan Jonases Lykka fick en ny tränare i Hagmyrens Wiktor Kylin-Blom den 2 juni.</p>



<p>Utan lopp i kroppen – Derbykvalet var första starten sedan december förra året – var hon mogen en rejäl rekordsänkning och fixade 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/2026/08/vildeabsudal-617x333.jpg" alt="" class="wp-image-883546"/><figcaption class="wp-element-caption">Vilde Absudal. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Hon har flera stora segrar som hästskötare och till exempel vann hennes passhäst <strong>Bore Mikkel</strong> (e. Moe Odin) Svenskt Kallblodsderby för tre år sedan. Så sent som i söndags fick hon se <strong>Björli Bas</strong> (e. Brenne Bas) krossa motståndet i Kriteriet på Dannero. Är det dags för en ny skötarseger för norskan Vilde Absudal i Derbyt?<br>Hon sköter nämligen tre av finalisterna från Öystein Tjomslands stall: <strong>Lannem Pär, Skeie Loke</strong> och <strong>Hallogubben</strong>.</p>



<p>Samma bedrift har Christina Kjönner lyckats med på stosidan, där hon har den dagliga skötseln av Jan Roar Mjölneröds trio <strong>Mjölner Tyra, Kleppe Nissemor</strong> och <strong>Sjö Lilja.</strong> Dessutom sitter Christina – precis som i Kriteriestoet och norska Oaks förra året där det blev segrar! – i vagnen bakom Kleppe Nissemor (e. Norheim Svenn).</p>



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



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



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



<li>Maja Torstemo – Py Viking</li>



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



<li>Vilde Abusdal – Lannem Pär</li>



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



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



<li>Emmelie Mood – Guli Kasper</li>



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



<li>Vilde Abusdal – Skeie Loke</li>



<li>Vilde Abusdal – Hallogubben</li>



<li>Clara Nordström – Oddfax</li>
</ul>



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



<ul class="wp-block-list">
<li>Christina Kjenner – Mjölner Tyra</li>



<li>Suvi Heikkinen – Tekla</li>



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



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



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



<li>Line Skoglund – Grevinnan Stöen</li>



<li>Christina Kjenner – Sjö Lilja</li>



<li>Johanna Frunck – Mamelukk Ö.K.</li>



<li>Celine Fåland Hansen – Skeie Ylva</li>



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



<li>Emelinda Persson – Komnes Fina</li>



<li>Linnea Fridh – Järvsö Josefin</li>
</ul>
