
<p class="has-drop-cap wp-block-paragraph">Hagmyrentränaren Stig Jarle Röste ordnade svensk seger i ena försöket till Derbystoet genom <strong>Hög Decibel</strong> (e. Art Kjarvald), som spurtade till lätt seger.<br>– Hon är inte helt klar i travet ännu och jag körde lite på säkerhet, sade Stig Jarle Röste efter försöksvinsten.</p>



<p class="wp-block-paragraph">Pappa <strong>Art Kjarvald</strong> (e. Mörtvedt Jerkeld), 1.20,4ak/2.972.042 kr, hade en lång och framgångsrik tävlingskarriär. Totalt blev det hela 177 starter (29-27-18) under maximala 13 säsonger på tävlingsbanan! Han vann minst ett lopp elva av de 13 åren på banan. Som unghäst kvalade han in till Derbyt i både Sverige och Norge, samt till norska Kriteriet.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2018/11/artkjarvaldupp-617x444.jpg" alt="travsport, trav, sulkysport, kallblod, avel" class="wp-image-33489"/><figcaption class="wp-element-caption">Art Kjarvald när han visades på avelsvärdering första gången 2015. Foto Berth Magnusson</figcaption></figure>



<p class="wp-block-paragraph">Men för att få kliva in i avelsboxen har Art Kjarvald – eller rättare sagt kretsen runt hingsten, Camilla och Stig Jarle Röste – har fått kämpa. När han visades 2015 blev han underkänd, då hans prestationer inte uppvägde det faktum att hingsten mättes till 144 centimeter över manken, den generella gränsen för avelshingstar är 148 centimeter.</p>



<p class="wp-block-paragraph">Tre år senare och med ytterligare egna prestationer på banan gjordes ett andra försök, men även denna gång gjorde avelsvärderingsnämnden tummen ned av samma anledning. Det beslutet överklagades till besvärsnämnden och i februari 2019 fick Art Kjarvald sitt avelsgodkännande.</p>



<p class="wp-block-paragraph">2019 fick han en avkomma, toppstoet Tekno Tana, 1.21,5ak*/1.263.548 kr. Bland elva avkommor födda 2020 finns fjolårets Derbyfinalist Teknologen, 1.24,2ak/602.317 kr. Bäst av 16 hästar i 2021-kullen är Hög Decibel, 1.25,0ak*/360.000 kr – vinnare av försök till Derbystoet för sin tränare Stig Jarle Röste.</p>



<p class="wp-block-paragraph">De tre hästarna är helsyskon! Mamma <strong>Teknologika</strong> (e. Tekno Odin), 1.26,1ak/181.885 kr, tävlade för en handfull norska tränare och var en flitig deltagare i unghästklassikerna. Hon kvalade in till final av Kriteriestoet både i Sverige och Norge som treåring, och svarade för samma bedrifter i Derbystoet som fyraåring. Bästa finalinsatsen var femteplatsen i Derbystoet i Östersund med Torbjörn Jansson i vagnen.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/hog-decibel-i-derbystoet/" target="_blank" rel="noreferrer noopener">––> Läs Sulkysports intervju med Camilla Röste inför Derbystoet här!</a></p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/08/hogdecibelheat-617x333.jpg" alt="" class="wp-image-753233"/><figcaption class="wp-element-caption">Hög Decibel och Stig Jarle Röste. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



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



<p class="wp-block-paragraph">2.140 meter autostart<br><em>Häst (far) – Kusk (tränare)</em></p>



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



<li><strong>Hög Decibel</strong> (e. Art Kjarvald) – Stig Jarle Röste</li>



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



<li><strong>Brenne Viktoria</strong> (e. Tekno Odin) – Åsbjörn Tengsareid (Jens Kristian Brenne)</li>



<li><strong>Guli Sanna</strong> (e. Ängsborken) – Mats Gällerstedt</li>



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



<li><strong>Mynta V.S.</strong> (e. Ängsborken) – Olli Kouvinen (Jörgen Westholm)</li>



<li><strong>R.M.G.Sommerfugl</strong> (e. Will Prinsen) – Tor A Eggan</li>



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



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



<li><strong>Salte Rappa</strong> (e. Norheim Svenn) – Tor R Salte (Öystein Tjomsland)</li>



<li><strong>M.P.Flora</strong> (e. Tekno Odin) – Ulf Ohlsson (Jerker Bjurman)</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/2025/08/halerke2-617x333.jpg" alt="" class="wp-image-753230"/><figcaption class="wp-element-caption">Hå Lerke och Öystein Tjomsland. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">De två starkaste norska korten i Derbystoet möttes redan i försöket och det slutade med utklassningsseger för Öystein Tjomslands <strong>Hå Lerke</strong> (e. Nordsjö Odin) före Jens Kristian Brennes <strong>Brenne Viktoria</strong> (e. Tekno Odin).<br>– Hon har inte haft så många passande lopp tidigare i år och samtidigt har siktet varit mot Derbystoet. Hon var väldigt lugn och fin idag, så det kändes skönt, sade Öystein Tjomsland efter försöket.</p>



<p class="wp-block-paragraph">Hå Lerke slutade trea i Kriteriestoet och femma i norska Stokriteriet förra året, medan Brenne Viktoria gjorde bort sig med galopp i kvalet på Dannero och följde upp me tredjeplatsen på Bjerke.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/08/brenneviktoria-617x333.jpg" alt="" class="wp-image-753228"/><figcaption class="wp-element-caption">Brenne Voktoria och Åsbjörn Tengsareid. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Med 22 starter innanför västen – bara <strong>M.P.Flora</strong> (e. Tekno Odin) har startar fler gånger, 23 – är Brenne Viktoria dubbelt så rutinerad som Hå Lerke. <br>Jens Kristian Brenne tränade även modern <strong>Brenne Blissi</strong> (e. Lome Elden), 1.23,0m/2.180.300 NOK, som vann 21 lopp, däribland Derbystoet i Östersund. Själv är hon syster med ytterligare tre (!) dubbelmiljonärer och framför allt världens snabbaste kallblod genom tiderna: <strong>Brenne Borken</strong> (e. Bork Odin)!</p>



<p class="wp-block-paragraph">Denne förpassade Järvsöfaks magiska 1.17,9 till historiebäckerna när han förra veckan slog till på 1.17,7a/1.640 meter i Gävle tillsammans med Öystein Tjomsland. I syskonskaran finns även <strong>Brenne Rödi</strong> (e. Horgen Tore), 2,6 miljoner och <strong>Brenne Odin</strong> (e. Moe Odin), 2,2 miljoner.</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/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 wp-block-paragraph">På tal om framgångsrika syskon. Jan-Olov Persson-tränade <strong>Eld Prinsessa</strong> (e. Tekno Odin), som körs av Örjan Kihlström, har en syskonskara som inte går av för hackor. Mamma <strong>Eldsiri</strong> (e. Järvsöfaks), 1.24,6ak/1.826.250 kr, vann 17 lopp på 32 starter. Bland segrarna märks Kriteriestoet på både Dannero och Bjerke, samt Stodebyt på Bjerke och Norskt Oaks på Momarken.</p>



<p class="wp-block-paragraph">Eldsiri är utsedd till Elitsto och hennes tolv avkommor – åtta i startbar ålder – har vunnit 65 av 242 starter och tjänat 7.930.636 kronor. Seger i Svenskt Kallblodskriterium har det blivit för <strong>Tekno Eld</strong> och <strong>Eld Rask</strong>, vinst i Norskt Kallblodsderby genom <strong>Tekno Eld</strong> och triumf i norskt Kallblodskriterium för <strong>Eld Rask</strong>.</p>



<p class="wp-block-paragraph">Sedan oktober 2022 ägs Eldsiri av Stall Segerhuva och hon köptes från uppfödaren Lennart Bäwerholm.</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/2025/08/bjorgen-617x333.jpg" alt="" class="wp-image-753226"/><figcaption class="wp-element-caption">Björgen och Per Linderoth. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Anders Wallin-tränade <strong>Björgen</strong> (e. Bork Odin) inledde karriären med fyra segrar (inklusive försök till Kriteriestoet) och ett andrapris på sina fem första starter innan hon satt fast som fyra i den stora finalen på Dannero. </p>



<p class="wp-block-paragraph">I säsongens elfte timme fick hon sin välförtjänta storloppsseger när Per Linderoth styrde till vinst i Norskt Oaks på Momarken.</p>



<p class="wp-block-paragraph">Björgen väntar fortfarande på första segern 2025, men har visat uppåtgående form och tog andraplatsen bakom Hög Decibel i kvalet till Derbystoet.</p>



<p class="wp-block-paragraph">Anders Wallin var länge mest känd för framgångar med varmblod, men av stallets åtta hästar är fem kallblod. Däribland segermaskinen Ulvsåsen (e. Åsajerven), 1.22,3m/1.601.900 kr, som startar i Sven O Perssons Minne idag, och fjolårets Derbystofinalist Guli Stina (e. Briskeby Philip), 1.25,4m/560.200 kr.</p>



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



<p class="has-drop-cap wp-block-paragraph">M<strong>ajblomsters </strong>segertid 1.24,3a/2.140 meter från förra året ä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 <strong>Patsi</strong> (e. Åsajerven) till vinst för nio år sedan på 1.23,9a. </p>



<p class="wp-block-paragraph">Ingen av dagens finalister har travat under 1.26 över distansen hittills i karriären.</p>



<p class="wp-block-paragraph"><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,5 – <strong>Stjärnblomster</strong> (e. B.W.Modde – Järvsö Blomster), 2018, Örjan Kihlström</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/2025/08/hertiginnanstoen-617x333.jpg" alt="" class="wp-image-753229"/><figcaption class="wp-element-caption">Hertiginnan Stöen och Mats E Djuse. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">M<strong>ajblomster </strong>följde upp seger i Kriteriestoet med att vinna Derbystoet under unghäståren. En stallkamrat kan göra samma resa idag. <strong>Hertiginnan Stöen</strong> (e. Tekno Odin), tränad av Jan-Olov Persson och körd av Mats E Djuse, var kullens drottning som treåring och vann även Stokriteriet på Bjerke.</p>



<p class="wp-block-paragraph">I år har det blivit en seger på sju försök, men också galopp i fyra av starterna. </p>



<p class="wp-block-paragraph">Mamma <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. </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 25 vinnare hittills sedan premiären 2000 är elva födda i Sverige. I derbyt är siffrorna 30-9 i norsk favör sedan norrmännen släpptes in 1986.</p>



<p class="wp-block-paragraph">Sedan Derbystoets förstapris uppgraderades rejält 2012 till 450.000 kronor har det dock blivit fyra svenska och nio 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 class="wp-block-paragraph">Ifjol bröts en lång norsk segersvit när <strong>Majblomster</strong> (e. Tekno Odin) slog till och åtta svenskfödda ston finns på startlinjen i årets upplaga.</p>



<p class="wp-block-paragraph">Bland Öystein Tjomslands tre finalister finns en blågul travare i <strong>Stavre Maggan</strong> (e. Tekno Odin), som slutade tvåa i Kriteriestoet ifjol.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/08/6majblomster3-617x333.jpg" alt="" class="wp-image-618978"/><figcaption class="wp-element-caption">Majblomster vid segern i Derbystoet i Östersund före Voje Lotta. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



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



<p class="has-drop-cap wp-block-paragraph">Förra året tog Tekno Odin sin andra seger som pappa i Derbystoet när dottern <strong>Majblomster</strong> vann. Den första kom 2022 med <strong>Nordsjö Anna</strong>. Idag har ha fem chanser till en tredje titel!</p>



<p class="wp-block-paragraph">Även Bork Odin med finalisten Björgen har vunnit Derbystoet som pappa. Precis som Tekno Odin vid två tillfällen tidigare, med <strong>Glade Tider</strong> 2019 och <strong>Norheim Borka</strong> 2020.<br>Nordsjö Odin har sin första kull fyraåringar och en finalist i klara favoriten <strong>Hå Lerke</strong>.</p>



<p class="wp-block-paragraph">Sju avelshingstar finns representerade i finalen och sex av dem är norska. Enda svenskfödda hingsten är <strong>Ängsborken</strong> (e. Bork Odin), som har två hästar i final: <strong>Guli Sanna</strong> och <strong>Mynta V.S.</strong> Ängsborken har sin andra kull fyraåringar. I debutkullen på stosidan finns dottern <strong>Voje Lotta</strong>, som var tvåa i Derbystoet förra året, men tog revansch genom att vinna Stoderbyt på Bjerke.</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/2018/09/stjrnblomsterpris2-617x329.jpg" alt="" class="wp-image-29830"/><figcaption class="wp-element-caption">Stjärnblomster och Örjan Kihlström. Foto Tom Jönehag</figcaption></figure>



<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 två tränare på två triumfer – en av dem är Jan-Olov Persson genom syskonen <strong>Stjärnblomster</strong> (e. B.W.Modde) och <strong>Majblomster</strong> (e. Tekno Odin). <br>Den andre Ö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 <strong>Karmine</strong> och <strong>Perleann</strong>.<br>Tjomsland (Hå Lerke), Kihlström (Eld Prinsessa) och Ohlsson (M.P.Flora) kör dagens final.</p>



<h2 class="wp-block-heading">Hästägare &#038; uppfödare Derbystoet</h2>



<p class="wp-block-paragraph"><em>Häst – Ägare – Uppfödare</em></p>



<ol class="wp-block-list">
<li><strong>Björgen</strong> – Bengt Eklund, med flera – Ingela Mårtensson, Bräcke</li>



<li><strong>Hög Decibel</strong> – Camilla A Röste, Hudiksvall – Camilla A Röste, Hudiksvall</li>



<li><strong>Hå Lerke</strong> – Bergsåkers Open Trotters KB – Stian &#038; Sigmund Nesvik, Norge</li>



<li><strong>Brenne Viktoria</strong> – Vidar Asgeir Brenne, Norge – Vidar Asgeir Brenne, Norge</li>



<li><strong>Guli Sanna</strong> – Jan Karlsson &#038; Ernst Nilsson – F Andersson &#038; HB Anderssons Hästar</li>



<li><strong>Stavre Maggan</strong> – Stall Stavre Maggan/Asap – Jörgen L Andersson, Offerdal</li>



<li><strong>Mynta V.S.</strong> – Manapå HB, med flera – Anneli Ek, Sala</li>



<li><strong>R.M.G.Sommerfugl</strong> – Marianne Landsem &#038; G Midtlyng, Norge – Marie &#038; Joar Leirfall, Norge</li>



<li><strong>Hertiginnan Stöen</strong> – Stall Ulmerkott – Kristine Stöen Kivle, Norge</li>



<li><strong>Eld Prinsessa</strong> – Lennart Bäwerholm &#038; Per Kirkerud – Lennart Bäwerholm, Norge</li>



<li><strong>Salte Rappa</strong> – Team Salte Rappa, Norge – Trond Olav Salte,Norge</li>



<li><strong>M.P.Flora</strong> – M Pettersson Konsult AB, me flera – M Pettersson Konsult AB, Umeå</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/matsgallerstedt-617x333.jpg" alt="" class="wp-image-490619"/><figcaption class="wp-element-caption">Mats Gällerstedt. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Att Umåker-tränaren Mats Gällerstedt och Skellefteåproffset Jerker Bjurman räknas som kallblodsexperter råder inga tvivel om. Av Gällersteds 22 hästar i träning finns bara ett varmblod. Bjurman har hundra procent kallblod i stallet, tio hästar.</p>



<p class="wp-block-paragraph"><strong>Guli Sanna</strong> (e. Ängsborken) är Mats Gällerstedts hopp. Stoet rekordsänkte med över en sekund i kvalet som trea. Hennes storasyster <strong>Guli Anna</strong> (e. Bork Odin) vann Kriteriestoet 2019 i Umåkerkollegan Stefan Johanssons regi.</p>



<p class="wp-block-paragraph">Jerker Bjurmans hopp <strong>M.P.Flora</strong> (e. Tekno Odin) är mest rutinerad i finalfältet med 23 starter (sex segrar) och hon kvalade in till kriteriestoet förra året. Hon har verkligen sina papper i ordning, där mormors mor är Elitstoet <strong>Tummelisa</strong> (e. Elding), som lämnat Derbyvinnaren <strong>Järvsöviking</strong> (e. Järvsöfaks).</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-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">Solvallatränaren Jörgen Westholm har å sin sida stor varmblodslutning på sin träningslista. Av 124 hästar är blott fyra kallblod, men det är spännande sådana. Som fjolårets dubble Derbyvinnare <strong>Frivoll Gorm</strong> (e. Ängsborken) anslät till stallet tidigare i sommar och var tvåa bakom Ulvsåsen i debuten i Westholms regi. En annan är <strong>Guli Hektor</strong> (e. Tekno Odin) med 13 segrar på 33 starter. Hektor är storebror till Derbystokonkurrenten <strong>Guli Sanna</strong> (e. Ängsborken).</p>



<p class="wp-block-paragraph">I <strong>Mynta V.S. </strong>(e. Ängsborken) har Westholm en storloppsvinnare. Mynta V.S. slog nämligen till i stoavdelningen av Sleipner Cup på Romme i juni och nästan fördubblade prissumman med 150.000 kronor.</p>



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



<p class="has-drop-cap wp-block-paragraph">Att ha en häst med i klassisk final är en dröm för många hästskötare. Maja Klar och Jenny Pettersson har till och med två sammanlagt i Derbyt och Derbystoet. Fast Jan-Olov Persson-duon står sig ändå slätt mot en norska.</p>



<p class="wp-block-paragraph">Celine Fåland Hansen, anställd hos Öystein Tjomsland, har hela fyra finalister!<br>Fast Celine är van hetluften och stora sammanhang. På Elitloppsdagen i år till exempel tog hon emot publikens hyllningar sedan <strong>Tangen Bork</strong> vunnit Elitkampen.</p>



<p class="wp-block-paragraph"><strong>Hästskötare Derbystoet</strong></p>



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



<li>Camilla Röste – Hög Decibel</li>



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



<li>Ellen Marie Folkvord – Brenne Viktoria</li>



<li>Camilla Hjärpe – Guli Sanna</li>



<li>Celine Fåland Hansen – Stavre Maggan</li>



<li>Sanna Gustavsson – Mynta V.S.</li>



<li>Tor A Eggen – R.M.G.Sommerfugl</li>



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



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



<li>Celine Fåland Hansen – Salte Rappa </li>



<li>Ranja Bjurman – M.P.Flora </li>
</ul>



<p class="wp-block-paragraph"><strong>Hästskötare Kallblodsderbyt</strong></p>



<ul class="wp-block-list">
<li>Stine Birkeland – Grisle Best G.L. </li>



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



<li>Chloe Pettersson – Hulte Adam</li>



<li>Engla Sund – Granbarksborren</li>



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



<li>Celine Fåland Hansen – Grude Erling</li>



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



<li>Maja Klar – Trollbalder</li>



<li>Anna-Karin Jonsson – Nordsjö Prinsen</li>



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



<li>Celine Fåland Hansen – Karmland Lukas</li>



<li>Maja Klar – B.W.Birger</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="QYQKvQF7X5"><a href="https://sulkysport.se/kallblodsdebryt-2025/">Derbyt: Tjomsland mot åtta raka</a></blockquote><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; visibility: hidden;" title="”Derbyt: Tjomsland mot åtta raka” &ndash; Sulkysport" src="https://sulkysport.se/kallblodsdebryt-2025/embed/#?secret=QfKucnM9Fl#?secret=QYQKvQF7X5" data-secret="QYQKvQF7X5" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe>
</div></figure>
