
<p class="has-drop-cap wp-block-paragraph">P<strong>hilip Ess, Nordsjö Odin, Havglimt, Tangen Bork, Tangen Minto</strong> och <strong>Bore Mikkel</strong>. Sex å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.<br>Tre chanser till närmast osannolika sjunde raka Derbysegern har Tjomsland, där <strong>Frivoll Gorm</strong> (e. Ängsborken) var snabbast av hans två försöksvinnare.</p>



<p class="wp-block-paragraph">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.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/08/boremikkel1-617x347.jpg" alt="" class="wp-image-479353"/><figcaption class="wp-element-caption">Bore Mikkel och Öystein Tjomsland var överlägsna i Derbyt ifjol. 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>Guldhagens Pirat (e. Ingbest) – Magnus A Djuse (Carl-Gustav Andersson)</li>



<li>Re Alkapital (e. Pydin) – Ulf Ohlsson (Öystein Tjomsland)</li>



<li>Frivoll Gorm (e. Ängsborken) – Tom Erik Solberg (Öystein Tjomsland)</li>



<li>Overvik Prinsen (e. Will Prinsen) – Vidar Hop (Frode Hamre)</li>



<li>Låhne Goliat (e. Galileo) – Geir Flåten</li>



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



<li>M.P.Atle (e. Tekno Odin) – Kristian Lindberg</li>



<li>Hå Lovde (e. Bork Odin) – Vidar Tjomsland (Öystein Tjomsland)</li>



<li>Bokli Leo (e. Galileo) – Svein Ove Wassberg (Geir Flåten)</li>



<li>Friska Viljan (e. Järvsö Björn) – Oskar Kylin Blom</li>



<li>Eld Vide C.G. (e. Tekno Eld) – Mats E Djuse (Jan-Olov Persson)</li>



<li>Teknologen (e. Tekno Odin) – Robert Skoglund</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/2024/07/realkapital-617x333.jpg" alt="" class="wp-image-614050"/><figcaption class="wp-element-caption">Re Alkapital och Ulf Ohlsson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">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 38 vinnare som korats: 29–9!</p>



<p class="wp-block-paragraph">I årets startfält är det liten övervikt Sverige på förhand, då sju av tolv finalister i Derbyt är födda här. Bland dessa finns två av tre försöksvinnare, Öystein Tjomslands <strong>Re Alkapital</strong> (e. Pydin) och Gävleamatören Carl-Gustav Anderssons <strong>Guldhagens Pirat</strong> (e. Ingbest).</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/2024/08/overvikprinsen6-617x333.jpg" alt="" class="wp-image-618515"/><figcaption class="wp-element-caption">Overvik Prinsen och Vidar Hop. 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.<br>Frode Hamre är tränaren som kan fylla på det antalet. Förra året hade <strong>Overvik Prinsen</strong> (e. Will Prinsen) en felfri säsong med nio starter och nio segrar. Hästen årsdebuterade i Derbykvalet och gjorde en fullgod insats som tvåa.</p>



<p class="wp-block-paragraph">Frode Hamre må skörda de största framgångarna med varmblod, men på meritlistan finns framför allt seger i norska Derbyt med <strong>Ingbest</strong> (e. Dotterud Teddy) 2016 och Stoderbyt med <strong>Karmland Anna</strong> (e. Bork Odin) 2018, innan Overvik Prinsens succéår ifjol med dubbla Kriterievinster.</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/2024/08/friskaviljan2-617x333.jpg" alt="" class="wp-image-618499"/><figcaption class="wp-element-caption">Friska Viljan och Oskar Kylin Blom. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">I söndags vann <strong>Gör Som Jag Vill</strong> (e. Järvsö Björn), 1.27,1am*/626.500 kr, Svenskt Kallblodskriterium på Dannero. Tre dagar senare har storebror <strong>Friska Viljan</strong> (e. Järvsö Björn), 1.24,5ak/459.532 kr, chansen att vinna Svenskt Kallblodsderby!</p>



<p class="wp-block-paragraph">Modern <strong>Lax Vilja</strong> (e. Moe Odin), 1.31,4ak/91.100 kr, som inte 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 class="wp-block-paragraph">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.<br>Bland syskonen finns också 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) och <strong>Björli Mai</strong> (595.854 kr).</p>



<p class="wp-block-paragraph"><strong>Bland finalisterna i Derbyt kan noteras noteras:</strong></p>



<ul class="wp-block-list">
<li><strong>Overvik Prinsens</strong> mamma Treve är till svenske Derbyvinnaren Philip Ess (e. Briskeby Philip), Kriterievinnaren Galileo (e. Järvsöfaks) och Kriteriestotvåan Malifika (e. Tekno Odin).</li>



<li><strong>Låhne Goliats</strong> mormor Voje Lykka (e. Lykkebron) är utsedd till Elitsto och har lämnat avelshingsten Voje Faks (e. Järvsöfaks, 1,8 miljoner.</li>



<li><strong>Ängsmoddes</strong> möderne går tillbaka till Bleikli Terna, mor till fenomenet Alm Rau Jo med 24 segrar och ett andrapris på 25 starter.</li>



<li><strong>M.P.Atles</strong> mamma Wikvinni (e. Mörtvedt Jerkeld) är syster med trippelmiljonären Wik Stjernen (e. Mörtvedt Jerkeld).</li>



<li><strong>Hå Lovde</strong> är lillebror till Holter Odin (e. Moe Odin), som var tvåa i både norska Kriteriet och Derbyt, och storebror till Hå Lerke (e. Nordsjö Odin), som var trea i kriteriestoet i söndags.</li>



<li><strong>Bokli Leo</strong> är lillebror till miljonärerna Bokli Rapp (e. Mörtvedt Jerkeld), Bokli Vind (e. Järvsöfaks) och Bokli Teddy (e. Dotterud Teddy).</li>



<li><strong>Eld Vide C.G:s</strong> mamma H.G.Grid (e. Lome Elden) är syster med unghäststjärnan H.G.Balder (e. Lome Elden), som Kriteriet i Sverige och Norge, Derbyt i Östersund, Biris Uppfödningslopp och slutade tvåa i norska Derbyt. I avelsboen är han pappa till Lome Brage.</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/joperssonrep06-617x444.jpg" alt="" class="wp-image-117286"/><figcaption class="wp-element-caption">Järvsöfaks. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">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 class="wp-block-paragraph">Moe Odin – som lämnade jordelivet förra året – tog sin fjärde svenska Derbyseger som far ifjol genom <strong>Bore Mikkel</strong> och gick därmed ifrån pappa Elding som stannade på tre triumfer. I år saknar han dock finalist i svenska Derbyt.</p>



<p class="wp-block-paragraph">Istället är Moe Odin farfar till <strong>Ängsmodde</strong> (e. B.W.Modde), <strong>M.P.Atle</strong> (e. Tekno Odin), och <strong>Hå Lovde</strong> (e. Bork Odin), samt farfars far till ytterligare fyra Derbyhästar: <strong>Re Alkapital</strong> (e. Pydin), <strong>Frivoll Gorm</strong> (e. Ängsborken), <strong>Overvik Prinsen</strong> (e. Ingbest) och <strong>Eld Vide C.G.</strong> (e. Tekno Eld).<br>Dessutom är han morfar till två hästar – <strong>Bokli Leo</strong> (e. Galileo) och <strong>Friska Viljan</strong> (e. Järvsö Björn) – och morfars far till <strong>Guldhagens Pirat</strong> (e. Ingbest) och <strong>Teknologen</strong> (e. Art Kjarvald).<br>Elva av tolv finalister har Moe Odin i stamtavlan. De ende som saknar championhingstens blod är <strong>Låhne Goliat</strong> (e. Galileo).</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: Moe Odin, Remin</li>



<li>Tre segrar: Alm Rigel, Elding, Skarphedin, Troll Jahn</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/2024/08/geirflatenoysteintjomsland-617x333.jpg" alt="" class="wp-image-618501"/><figcaption class="wp-element-caption">Geir Flåten och Öystein Tjomsland. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Av avelshingstarna i Kallblodsderbyt har två lämnat vinnare tidigare. Bork Odin, som är far till <strong>Hå Lodve</strong>, var pappa till vinnaren två år i rad. 2021 vann <strong>Tangen Bork</strong> och 2022 segrade <strong>Tangen Minto</strong>.</p>



<p class="wp-block-paragraph"><strong>Tekno Odin</strong>, som själv vann Derbyt 2012, har en vinnare på sitt cv i 2019 års etta <strong>Nordsjö Odin</strong>. I år ställer Sveriges championhingst de senaste åren hoppet till <strong>M.P.Atle</strong>.</p>



<p class="wp-block-paragraph">En hingst har två finalister i startfältet: norske Järvsöfaks-sonen <strong>Galileo</strong> som hoppas på Geir Flåtens duo <strong>Låhne Goliat</strong> och <strong>Bokli Leo</strong>. För Galileo kan sönerna ge skön revansch för pappans egen start i Svenskt Kallblodsderby. Galileo galopperade nämligen som storfavorit och fick nöja sig med femteplatsen tillsammans med Geir Flåten 2016. Däremot vann Galileo Kriteriet på Dannero året före.</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/2024/07/frivollgorm-617x333.jpg" alt="" class="wp-image-614029"/><figcaption class="wp-element-caption">Frivoll Gorm slog Overvik Prinsen i Derbykvalet. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Ä<strong>ngsborken</strong> (e. Bork Odin) har sin första kull fyraåringar på banan och den under flera säsonger populäre avelshingsten kan få en mycket spännande kväll. Han är nämligen pappa till förhandsfavoriten i Derbyt, <strong>Frivoll Gorm</strong>, och dessutom far till starka stona <strong>Voje Lotta</strong> och <strong>Ängspuma</strong> i Derbystoet.<br>I hingstens första kull finns 37 svenskfödda och sju norska hästar och tre av dem är alltså med i finalerna.</p>



<p class="wp-block-paragraph">Första kullen handlar det också om för <strong>Tekno Eld</strong> (e. Tekno Odin), som slutade tvåa i svenska Derbyt men vann det norska liksom Kriteriet på Dannero som unghäst. Hingsten är numera såld till Norge, men fick i sin första kull 44 svenska och sex norska avkommor. <strong>Eld Vide C.G.</strong> kvalade in till Derbyt, medan <strong>Järvsö Britt</strong> startar i Derbystoets final.</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/2024/08/teknologen-617x333.jpg" alt="" class="wp-image-617433"/><figcaption class="wp-element-caption">Teknologen. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Försöksvinnaren Re Alkapitals pappa <strong>Pydin</strong> (e. Moe Odin), 1.20,1ak*/3.389.294 kr, som är uppfödd av ägs av Bo Torstemo, är fortsatt aktiv på tävlingsbanan i regi ägarsonen Niclas och startar på onsdagskvällen i Sven O Perssons Minne i Östersund.<br>Han har smygstartat i aveln med första avkomman född 2019 i ostartade Grindbackens Elma. I Derbykullen finns tre avkommor med Derbyfinalisten Re Alkapital i spetsen.<br>Pydin har fyllt på med två avkommor födda 2021, och båda har vunnit lopp! <strong>Zevs</strong>, 1.32,2m*/49.000 kr, har två segrar dessutom och <strong>Pyseidon</strong>, 1.32,1m*/44.000 kr.</p>



<p class="wp-block-paragraph"><strong>Art Kjarvald</strong> (e. Mörtvedt Jerkeld) har endast en avkomma i sin första kull född 2019, duktiga stoet <strong>Tekno Tana</strong>, 1.24,2ak/612.100 kr. Derbykullen innehåller elva avkommor och ur denna har kommit Tekno Tanas helbror <strong>Teknologen</strong>, 1.24,2ak/385.900 kr, som ordnade en Derbybiljett i kvalen.</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/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 wp-block-paragraph">Kriteriestoet på Dannero. Stokriteriet på Bjerke. Oaks på Momarken. Jan-Olov Persson-tränade <strong>Majblomster</strong> (e. Tekno Odin) hade en sagolik treåringssäsong, där kronan på verket var världsrekordet 1.23,6a/2.100 meter vid storsegern på Bjerke.</p>



<p class="wp-block-paragraph">I år har hon varit fläckfri. Sex starter har givit lika många segrar, men hon har fått plocka fram allt vissa gånger för att vinna. Som när <strong>Ängspuma</strong> (e. Ängsborken) stred hela vägen i Sleipner Cup-finalen, eller när <strong>Voje Lotta</strong> (e. Ängsborken) rundade Majblomster in i slutsvängen i Derbystokvalet. Båda gångerna visade Majblomster att hon vet var mållinjen ligger.</p>



<p class="wp-block-paragraph">Segertiden i försöket var 1.25,0a/2.140 meter. Det kan jämföras med de andra två försöksvinnarna <strong>Troll Sterkfaksine</strong> (e. Tekno Odin), som travade 1.28,3a och <strong>Prinsesse Ness Tjo</strong> (e. Moe Odin) som bara behövde trava 1.29,5a.</p>



<p class="wp-block-paragraph">Majblomster har ju ”det” i blodet. Den senaste svenskfödda vinnaren i Derbystoet är hennes storasyster <strong>Stjärnblomster</strong> (e. B.W.Modde), som vann 2018 års upplaga tillsammans med Örjan Kihlström. Jan-Olov Persson tränar systrarna.</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>Troll Sterkfaksine (e. Tekno Odin) – Jan Roar Mjölneröd</li>



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



<li>Prinsesse Ness Tjo (e. Moe Odin) – Björn Steine (John Ragnvald Ness)</li>



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



<li>Ängspuma (e. Ängsborken) – Robert Skoglund</li>



<li>Backeballerina (e. Tekno Odin) – Björn Karlsson</li>



<li>Alfinga (e. Ingbest) – Ingvar Nyberg (Lars-Erik Karlsson)</li>



<li>Prinsessan Stöen (e. Bork Odin) – Örjan Kihlström (Jan-Olov Persson)</li>



<li>Voje Lotta (e. Ängsborken) – Lars Anvar Kolle (Jan Kristian Överdal)</li>



<li>Eskils Oda (e. Tekno Odin – Ulf Eriksson (Klas Wahlberg)</li>



<li>Guli Stina (e. Briskeby Philip) – Anders Wallin</li>



<li>Järvsö Britt (e. Tekno Eld) – Tomas Pettersson (Jan-Olov Persson)</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/2024/08/robertskoglund-617x333.jpg" alt="" class="wp-image-617436"/><figcaption class="wp-element-caption">Robert Skoglund. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Robert Skoglund kommer full av självförtroende till Östersunds Derbykväll efter triumfen i Kriteriet med <strong>Gör Som Jag Vill</strong> (e. Järvsö Björn) i söndags. Han har <strong>Teknologen</strong> (e. Tekno Odin) i Derbyt, men ställer största hoppet till <strong>Ängspuma</strong> (e. Ängsborken) i Derbystoet.</p>



<p class="wp-block-paragraph"><strong>Tankarna inför?</strong><br>– Enbart positiva. Vi fick spår fem bakom bilen och det är idealiskt för då kan hon öppna ganska bra. Allt är bra i jobben och hon går med samma utrustning som tidigare. Jag anser hon har bättre chans att vinna derbyt än vad Gör Som Jag Vill hade att vinna kriteriet även om jag har stor respekt för både Troll Sterkfaksine och Majblomster, säger Robert Skoglund.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/infor-v86-skoglund-har-en-riktigt-vass-puma/" target="_blank" rel="noreferrer noopener">Läs hela intervjun med Bergsåkertränaren inför Derbykvällen här!</a></p>



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



<p class="has-drop-cap wp-block-paragraph">I Derbystoet har de svenskfödda kallbloden stått sig starkare, i alla fall under loppets första decennium. Av 24 vinnare hittills sedan premiären 2000 är tio födda i Sverige. Sedan Derbystoets förstapris uppgraderades rejält 2012 till 450.000 kronor har det dock blivit tre svenska och nio norska vinster.</p>



<p class="wp-block-paragraph">Sedan 2022 tävlar stona om samma prispengar som hingstarna och valackerna, då vinnarna i båda klasserna får 600.000 vardera.<br>Nu har det blivit norsk seger fem år i rad och hela nio svenskfödda ston finns på startlinjen i årets upplaga för att bryta den sviten. </p>



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



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



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



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



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



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



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



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



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



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



<li>2018 Stjärnblomster (e. B.W.Modde) – Ö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/2024/07/trollsterkfaksine-617x333.jpg" alt="" class="wp-image-614051"/><figcaption class="wp-element-caption">Troll Sterkfaksine och Jan Roar Mjölneröd. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Årets norska ”lag” är minst sagt starkt. Jan Roar Mjölneröds <strong>Troll Sterkfaksine</strong> (e. Tekno Odin) slutade tvåa bakom Majblomster i både norska Kriteriestoet och Oaks, och besegrade faktiskt svenskan i uttagningsloppet till Stokriteriet.</p>



<p class="wp-block-paragraph">Uppstickaren – om man nu kan kalla en häst med elva (!) raka segrar för det – är <strong>Prinsesse Ness Tjo</strong> (e. Moe Odin). Med ett lopp i kroppen slutade hon förra året tvåa i försök till Kriteriestoet på Dannero på 1.27,5a/2.140 meter. Det blev tufft för stoet, som galopperade i finalen (sexa) och var oplacerad i kvalet till norska Stokriteriet. <br>Sedan blev det ett längre uppehåll innan hon var tillbaka på banan strax före jul och vann direkt. Sedan dess har det blivit ytterligare tio segrar på raken för John Ragnvald Ness sto!</p>



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



<p class="has-drop-cap wp-block-paragraph">Öystein Tjomsland är den store dominanten i Derbystoets historia med fem vinster som tränare. Bakom honom finns det bara en tränare på två triumfer – och det är inte Jan-Olov Persson. Istället handlar det om Östersundsamatören Kent Hafstad som tog dubbla segrar genom <strong>Karmine</strong> (e. Marine Svarten) 2004 och <strong>Perleann</strong> (e. Gullsvarten) 2007.</p>



<p class="wp-block-paragraph">Tjomsland är också den mest framgångsrike kusken med fyra segrar. Örjan Kihlström skuggar 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. Åkes segerhästar är <strong>Ellerina</strong> och <strong>Lykkeli</strong>, medan Ohlsson segrade med Kent Hafstads duo Karmine och Perleann.</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/2024/08/prinsessestoen-617x333.jpg" alt="" class="wp-image-618510"/><figcaption class="wp-element-caption">Prinsessan Stöen. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Precis som i Kallblodsderbyt kan det bli dubbelsuccé för ett fölsto i Derbystoet. <strong>Vesle Fröken Stöen</strong> (e. Spikeld), 1.23,7am/1.451.358 kr, är mamma till söndagens Kriteriestoetta <strong>Hertiginnan Stöen</strong> (e. Tekno Odin) och från samma stall, Jan-Olov Persson, kommer storasyster <strong>Prinsessan Stöen</strong> (Bork Odin) till start i Derbystoets final.</p>



<p class="wp-block-paragraph">Vesle Fröken Stöen 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. <br>Hennes tre första avkommor blev norskregistrerade med <strong>Lille Fröken Stöen</strong> (e. Bork Odin), 1.25,2ak/368.532 kr, som den bäste. Sedan 2020 är avkommorna svenskregistrerade.</p>



<p class="wp-block-paragraph">Vesle Fröken Stöens mamma <strong>Voje Vira</strong> (e. Järvsöfaks) är utsedd till Elitsto. Hon har även lämnat <strong>Teddy Gutten Stöen</strong> (e. Horgen Tore), 1.22,0ak/2.055.937 kr, som var trea i norska Derbyt.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/07/prinsessenesstjo-617x333.jpg" alt="" class="wp-image-614049"/><figcaption class="wp-element-caption">Prinsesse Ness Tjo och Björn Steine. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph"><strong>Bland finalisterna i Derbystoet kan noteras noteras:</strong></p>



<ul class="wp-block-list">
<li><strong>Prinsesse Ness Tjos</strong> mamma Ness Tjo Stjerna (e. Mörtvedt Jerkeld) slutade tvåa i Stokriteriet i Norge.</li>



<li>Moe Syn, mor till <strong>Garli Andrea</strong>, är syster till självaste championhingsten Moe Odin (10 miljoner). I syskonskaran finns även Moe Svarten (2,5 miljoner) och Moe Granar (1,5 miljoner).</li>



<li>Ängsrappa, mor till <strong>Ängspuma</strong>, har även lämnat Derbytrean 2016, Ängsrappen (e. Järvsöfaks) och nästanmiljonärskan Ängsthea, fyra i norska Stoderbyt.</li>



<li>Norm Maja, mor till <strong>Backeballerina</strong>, var tvåa i Kriteriestoet.</li>



<li>Alfia, mor till <strong>Alfinga</strong>, har lämnat dubbelmiljonärskan Alfa Lina (e. Klack Jo), som var tvåa i både norska Stokriteriet och Oaks som treåring och tvåa i Stoderbyt på Bjerke som fyraåring. Då slutade hon även fyra i Derbystoet.</li>



<li>Voje Spika, mor till <strong>Voje Lotta</strong>, vann själv norskt Oaks och har lämnat Voje Maren (e. Åsajerven, vinnare av Kriteriestoet, och Voje Piril (e. Hellin Faxen), trea i norska Derbyt.</li>



<li>Sjö Spira, mor till <strong>Eskils Oda</strong>, är syster med Sjö Kongen (2,1 miljoner), Sjö Odin (1,6 miljoner) och Sjö Vinn (1,3 miljoner). Sjö Vinn vann Kriteriet på Dannero 2016, Sjö Kongen var tvåa i norska Kriteriet, medan Sjö Odin var trea i Kriteriet och Derbyt i Sverige. I syskonskaran finns också Kriterietvåan Sjö Gull och Derbystotrean Sjö Stjerna.</li>



<li><strong>Guli Stina </strong>är syster till miljonärerna Guli Roy och Guli Frodo och kommer från samma möderne som Elitstoet Eldsiri, mor till Tekno Eld och Eld Rask.</li>



<li><strong>Järvsö Britts</strong> mormors mormor är självaste <strong>Buaas Stjerna</strong> (född e. Troll Jahn), 1.22,3ak*/3.741.859 kr, som slog hingstarna när hon vann Svenskt Kallblodsderby tillsammans med Jomar Blekkan 1991. Det var en av stoets 44 segrar – på 213 starter!</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">Tekno Odin tog sin första och enda seger i svenska Derbystoet för två år sedan genom <strong>Nordsjö Anna</strong>. I årets final har han hela fyra chanser att fördubbla segerantalet genom döttrarna <strong>Troll Sterkfaksine, Majblomster</strong>, <strong>Backeballerina</strong> och <strong>Eskils Oda</strong>.</p>



<p class="wp-block-paragraph">Av avelshingstarna som tidigare haft en vinnare finns också<strong> Bork Odin</strong> (Glade Tider 2019 och Norheim Borka 2020), <strong>Moe Odin</strong> (B.W.Gullis 2016) och <strong>Briskeby Philip</strong> (Bodbäckssiv 2014).<br>Bork Odin har två finalister, medan debuthingstarna Ängsborken och Tekno Eld har två respektive en finalist.</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/11/hannaedvinssonteknoeld-617x333.jpg" alt="" class="wp-image-520056"/><figcaption class="wp-element-caption">Hanna Edvinsson och Tekno Eld. Foto Mia Törnberg/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Hanna Edvinsson tillhör de skötare som haft Järvsöfaks i sin vård under hästens fenomenala tävlingskarriär, men hos Jan-Olov Persson skötte hon även topphästar som helbröderna <strong>Tekno Eld</strong> och <strong>Eld Rask</strong>. Båda hästarna vann bland annat Kriteriet på Dannero, men i Derbyt i Östersund gick de bet. Tekno Eld slutade tvåa i finalen bakom <strong>Philip Ess</strong> (e. Briskeby Phlip), medan skada stoppade Eld Rask från att starta. Fast en fick Hanna jubla åt till slut när Tekno Eld vann Derbyt på Bjerke.</p>



<p class="wp-block-paragraph">Numera arbetar hon hos Öystein Tjomsland och har en ny chans i svenska Derbyt, då hon sköter försöksvinnaren <strong>Frivoll Gorm</strong>.</p>



<p class="wp-block-paragraph">Flera skötare måste hålla blicken åt två håll med dubbla finalister: Lene Flåten har två Derbyhästar, Jenny Pettersson har två hästar i Derbystoet, medan Johanna Frunck delat på gracerna med en finalist i vardera klass. </p>



<h2 class="wp-block-heading">Skötarna i Kallblodsderbyt</h2>



<ul class="wp-block-list">
<li>Guldhagens Pirat – Charlotte Andersson</li>



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



<li>Frivoll Gorm – Hanna Edvinsson</li>



<li>Overvik Prinsen – Tina Storetvedt</li>



<li>Låhne Goliat – Lene Flåten</li>



<li>Ängsmodde – Silje Röste</li>



<li>M.P.Atle – Jenny Eriksson</li>



<li>Hå Lovde – Celine Fåland Hansen</li>



<li>Bokli Leo – Lene Flåten</li>



<li>Friska Viljan – Petra Lindberg</li>



<li>Eld Vide C.G. – Engla Sund</li>



<li>Teknologen – Johanna Frunck</li>
</ul>



<h2 class="wp-block-heading">Skötarna i Derbystoet</h2>



<ul class="wp-block-list">
<li>Troll Sterkfaksine – Christina Kjenner</li>



<li>Majblomster – Jenny Pettersson</li>



<li>Prinsesse Ness Jo – John Ragnvald Ness</li>



<li>Garli Andrea – Sandra Gjeruldsen</li>



<li>Ängspuma – Johanna Frunck</li>



<li>Backeballerina – Isabelle Karlsson</li>



<li>Alfinga – Carina Bergström</li>



<li>Prinsessan Stöen – Isabelle Isaksson</li>



<li>Voje Lotta – Harald Överdal</li>



<li>Eskils Oda – Amalia Larsson</li>



<li>Guli Stina – Peter Näslund</li>



<li>Järvsö Britt – Jenny Pettersson</li>
</ul>
