
<p class="has-drop-cap wp-block-paragraph">Derbystoets tränardominant genom tiderna heter Stig H Johansson. Fem gånger har ett fyraårigt sto i hans träning vunnit loppet: <strong>Note Broline, Balcony I.T, Miss Pilaar, Je t’Aime Dream</strong> och <strong>Bobtail</strong>.</p>



<p class="wp-block-paragraph">Peter Untersteiner plockade tre tränarsegrar – <strong>Neona Princess, Otrobanda</strong> och <strong>Run Chica Run</strong> – innan sonen Johan blev chef för träningsstallet och idag ställer sitt hopp till <strong>Elegance Silvio</strong> (e. Maharajah) idag.</p>



<p class="wp-block-paragraph">Lika många har Timo Nurmos, som kan kliva upp på ensam andraplats vid seger under söndagen för hans hopp <strong>Ulaya</strong> (e. Love You). Det tyskägda stoet är unik i årets finalfält på flera sätt. Att hon gjort minst antal starter är ett, desto viktigare är att hon aldrig förlorat travlopp.</p>



<p class="wp-block-paragraph">Åtta starter har givit lika många segrar, där de tre första togs i Hamburg i Loset Franzls regi sent under treåringssäsongen. I slutet av november klev hon in i Timo Nurmos stall och där fortsatte segertåget med två vårvinster och sedan tre raka i sommar. I försöken till Derbystoet var hon snabbast av alla vinnare med 1.12,0a/2.140 meter.<br>– Det blir spännande. Det känns som att hon är under utveckling. Jag vet inte riktigt hur bra hon är. Hon har kanske inte gått i botten någon gång, säger Magnus A Djuse.</p>



<p class="wp-block-paragraph">Mormors mormor till Ulaya är <strong>Petite Evander</strong> (e. Great Evander), 1.13,4/$736.619, som deltog i Elitloppet och det gjorde också hennes dotter <strong>Pride of Petite</strong> (e. Royal Prestige), 1.12,4/NZD$811.816.</p>



<p class="wp-block-paragraph">Petite Evander var med två gånger på Solvalla, men lyckades inte ta sig till final vid något tillfälle, medan Pride of Petite var oplacerad i finalen efter en fjärdeplats i försöket.</p>



<p class="wp-block-paragraph"><strong>Patricia du Ling, Evin Boko</strong> och <strong>Lara Boko</strong> är Timos vinnare genom åren.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/05/s.g.empressrw-617x333.jpg" alt="" class="wp-image-725891"/><figcaption class="wp-element-caption">S.G.Empress och Roger Walmann. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Förutom Timo Nurmos vet ytterligare en av tränarna bakom dagens finalister hur det känns att vinna Derbystoet. Roger Walmann har två titlar. Den första kom redan 1994 med Handbag, medan seger två dröjde 15 år till 2009 när Calamara Donna triumferade. S.G.Empress (e. Readly Express) är hästen som kan ordna en tredje titel.</p>



<p class="wp-block-paragraph">Fuxan har slagit i nästan alla stora slag hittills under karriären. Som treåring vann hon korta E3 och slutade trea i Breeders Crown-finalen, men gjorde bort sig med galopp i både långa E3 och Svenskt Trav-Oaks. I år har hon slutat trea i Stochampionatet, men också galopperat bort sig i Drottning Silvias Pokal.</p>



<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>Love This Bar</strong> (e. Django Riff) – Adrian Kolgjini</li>



<li><strong>Elegance Silvio</strong> (e. Maharajah) – Johan Untersteiner</li>



<li><strong>Tangerina</strong> (e. Perfect Spirit) – Carl Johan Jepson (Ulf Stenströmer)</li>



<li><strong>S.G. Empress</strong> (e. Readly Express) – Rikard N Skoglund (Roger Walmann)</li>



<li><strong>Ulaya</strong> (e. Love You) – Magnus A Djuse (Timo Nurmos)</li>



<li><strong>Giraffa</strong> (e. Maharajah) – Conrad Lugauer</li>



<li><strong>Vivillion</strong> (e. Propulsion) – Mats E Djuse (Daniel Wäjersten)</li>



<li><strong>Zucchini C.D.</strong> (e. Uncle Lasse) – Robert Bergh</li>



<li><strong>Screen Time Limit</strong> (e. Face Time Bourbon) – Daniel Wäjersten</li>



<li><strong>Love Bites</strong> (e. Greenshoe) – Örjan Kihlström (Marcus Schön)</li>



<li><strong>Juni Brick</strong> (e. Nuncio) – Björn Goop (Philip Di Luca)</li>



<li><strong>Tintarella</strong> (e. Fabulous Wood) – Robin Bakker (Thomas Dalborg)</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">En miljon i förstapris i Derbystoet? Nej, två miljoner! Alla tolv finalisterna i loppet är med i premiechansen och därmed blir prisskalan i finalen så här:<br>2.000.000–1.000.000–500.000–240.000–160.000–100.000 kronor.</p>



<p class="wp-block-paragraph">De tio senaste vinnarna av loppet har alla varit premiechansade och fått dubbla prischecken.</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/10/10vivillion2-617x333.jpg" alt="" class="wp-image-645598"/><figcaption class="wp-element-caption">Vivillion, Daniel Wäjersten och skötaren Ebba Karbelius efter segern i Svenskt-Trav Oaks. Nu jagar de segern i Drottningens pokal. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Att ta dubbeln Svenskt Trav-Oaks och Derbystoet är inte speciellt vanligt. Det har hänt fem gånger i loppets historia och senast i raden är <strong>Lara Boko</strong> (e. Djali Boko) 2021-2022.</p>



<p class="wp-block-paragraph">I år kan Daniel Wäjersten-tränade <strong>Vivillion</strong> (e. Propulsion) göra den dubbelvinnande kvintetten sällskap, sedan hon kvalat in till Derbystoet via andraplats i försöket. Vivillion stod över Stochampionatet i somras, men var finalist i både Drottning Silvias Pokal (tvåa) och Stosprintern (sexa).</p>



<p class="wp-block-paragraph"><strong>Ston som tagit dubbeln Oaks och Derbystoet:</strong></p>



<ul class="wp-block-list">
<li>Pine Princess (e. Napoletano) 1998-1999 – Nils Sylvén (a)</li>



<li>Je t’Aime Dream (e. Sugarcane Hanover) 2001-2002 – Stig H Johansson</li>



<li>Fascination (e. Super Arnie) 2012-2013 – Lars I Nilsson</li>



<li>Diana Zet (e. Hard Livin) 2019-2020 – Daniel Redén</li>



<li>Lara Boko (e. Djali Boko) 2021-2022 – Timo Nurmos</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">Daniel Wäjersten är ensam om att ha kvalat in två hästar till Derbystoet. Medan Mats E Djuse får chansen bakom Vivillion kör Bergsåkertränaren själv <strong>Screen Time Limit</strong> (e. Face Time Bourbon), som i Reijo Liljendahls regi tog karriärens störstas seger förra sommaren i långa E3-finalen. </p>



<p class="wp-block-paragraph">Screen Time Limit kan annars luta sig mot två starka andraplatser för Wäjersten: i Breeders Crown-finalen ifjol och i sommarens Stochampionatet, båda loppen med <strong>La Yuca</strong> (e. Face Time Bourbon) som vinnare.<br>Stochampionatsvinnaren La Yuca saknas i Derbystoet och startar istället senare under söndagseftermiddagen som en av favoriterna i Svenskt Travderby.</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/07/tangerina-617x333.jpg" alt="" class="wp-image-744578"/><figcaption class="wp-element-caption">Ulf Stenströmer-tränade Tangerina slutade sexa i Svenskt Trav-Oaks förra året. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Fem av finalisterna i Stochampionatet i juli har tagit sig till final i Derbystoet. Förutom tvåan Screen Time Limit och trean S.G.Empress handlar det om <strong>Elegance Silvio</strong> (e. Maharajah), <strong>Tangerina</strong> (e. Perfect Spirit) och <strong>Tintarella</strong> (e. Fabulous Wood).</p>



<p class="wp-block-paragraph">Johan Untersteiners Elegance Silvio har sin främsta merit i andraplatsen i Stosprintern på hemmaplan.<br>Auktionsfyndet Tangerina – läs mer nedan – kvalade in till Svenskt Trav-Oaks förra året och tog sjätteplatsen där. <br>Tintarella tränas av Axevallas Thomas Dalborg och gjorde sin storloppsdebut för 1,5 månader sedan. </p>



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



<p class="has-drop-cap wp-block-paragraph">Fyra kullar på tävlingsbanan hittills i Derbystoet och två segrar. Bakom detta resultat står Readly Express, som sett döttrarna <strong>Honey Mearas</strong> och ifjol <strong>Daim Brodda</strong> ta hem storloppet på Jägersro. I år har han chansen till en ny triumf genom S.G.Empress.</p>



<p class="wp-block-paragraph">Elva avelshingstar står bakom de tolv finalisterna och Sveriges flerfaldige champion Maharajah är ensam om två finalister. Elegance Silvio respektive Giraffa är stona som kan ge pappa första segern i Derbystoet efter tolv tidigare försök.</p>



<p class="wp-block-paragraph">Hela sex avelshingstar har sin första finalist i loppet.</p>



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



<p class="wp-block-paragraph"><em>Hingst (antal 2025) – Totalt – Finalister</em></p>



<ul class="wp-block-list">
<li><strong>Love You</strong> (1) – 5 – Abborren (5) 2012, Hankypanky Pagan (0) 2013, Donna di Quattro (0) 2014, Fanny Chenal (6) 2019, Hankypanky Rubyred (0) 2019 </li>



<li><strong>Maharajah</strong> (2) – 12 – Mulligan (2) 2017, Unstirred Bright (0) 2017, Maharani de Baroda (5) 2018, Veroni (0) 2018, Aleppo Pine (0) 2019, Call Me Brodda (0) 2019, Mahma Lane (6) 2020, Mellby Harissa (0) 2020, Juni Rapid (5) 2021, Mellby Korall (3) 2023, Carmita Silvio (0) 2024, Flamenco Girl (0) 2024</li>



<li><strong>Nuncio</strong> (1) – 1 – Queen Belina (4) 2023</li>



<li><strong>Propulsion</strong> (1) – 4 – Jennifer Sisu (2) 2023, Mahala (6) 2023, Bikana Wine (0) 2023, Mi Amore Bros (0) 2023</li>



<li><strong>Readly Express</strong> (1) – 4 – <strong>Honey Mearas</strong> (1) 2021, Tilda Express (0) 2021, Aurelia Express (0) 2023, <strong>Daim Brodda</strong> (1) 2024</li>
</ul>



<p class="wp-block-paragraph">Django Riff (1), Fabulous Wood (1), Face Time Bourbon (1), Greenshoe (1), Perfect Spirit (1) och Uncle Lasse (1) har sin första finalist i Derbystoet. </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/09/jovialityeam230903adamstromstalltz-617x403.jpg" alt="" class="wp-image-491719"/><figcaption class="wp-element-caption">Joviality och Erik Adielsson vann Svenskt Travderby före Adrian Kolgjinis Barack Face. Foto Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Stall Courant som ägare och Am Bloodstock som uppfödare triumferade i Svenskt Travderby för två år sedan genom superstoet <strong>Joviality</strong> (e. Chapter Seven). Någon seger i Derbystoet har dock inte hårdsatsande Anders Ström, men idag finn chansen.</p>



<p class="wp-block-paragraph">Marcus Schön tränar <strong>Love Bites</strong> (e. Greenshoe) som vunnit tre av 14 starter inför eftermiddagens stora uppgift.</p>



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



<p class="has-drop-cap wp-block-paragraph">Nio amerikanska, två franska och en norsk avelshingst. Där har ni morfäderna bakom Derbystoets tolv finalister.</p>



<p class="wp-block-paragraph"><strong>Gente Star</strong> (e. Speedy Tomali) var Norges kanske största stjärna på 1990-talet i Ginleif Tollefsens regi och vann 32 och 43 starter. De största prischeckarna togs i Sverige som femåring i Åby Stora Pris respektive Solvallas Jubileumspokal.</p>



<p class="wp-block-paragraph">I avelsboxen lämnade han <strong>Spring Erom</strong> (8,2 miljoner), <strong>Spring Ray</strong> (6,9 miljoner), <strong>Gentleman</strong> (4,8 miljoner) och S.G.Empress mamma <strong>Riva del Sole</strong>, 1.11,5ak*/3.716.024 kr. Riva del Sole är även mamma till <strong>S.G.Dracarys</strong> (e. Bold Eagle), 1.10,5ak/2.762.500 kr.</p>



<h2 class="wp-block-heading">Morfäder i Derbystoet</h2>



<p class="wp-block-paragraph"><em>Morfar (antal 2025) – Totalt – Finalister</em></p>



<ul class="wp-block-list">
<li><strong>Chocolatier</strong> (1) – 2 – Fanny Chenal (6) 2019, Dontlooseallmoney (0) 2020</li>



<li><strong>Dream Vaction</strong> (1) – 1 – Mulligan (2) 2017</li>



<li><strong>Love You</strong> (1) – 3 – Hoboken Am (6) 2021, Mirci A’lir (0) 2022, Caia (4) 2024</li>



<li><strong>Muscle Hill</strong> (1) – 5 – <strong>Lara Boko</strong> (1) 2022, Glorius Rain (3) 2022, Julia Sisu (0) 2023, Dial Square (2) 2024, Pure Diamond (6) 2024</li>



<li><strong>Muscles Yankee</strong> (1) – 9 – Caviar’s Goldcard (0) 2013, Caresse (4) 2016, Darling Hornline (0) 2016, Bella Mont (4) 2017, Mellby Fashion (0) 2018, Milady Grace (2) 2020, <strong>Honey Mearas</strong> (1) 2021, <strong>Global Dancer</strong> (1) 2023, Queen Belina (4) 2023, </li>



<li><strong>Orlando Vici</strong> (1) – 1 – Carmita Silvio (0) 2024</li>



<li><strong>S.J.’s Caviar</strong> (1) – 1 – Backfire (4) 2014</li>



<li><strong>Yankee Glide</strong> (1) – 3 – Kiss Me Kemp (0) 2013, Bugatti Brick (0) 2017, Xia Lloyd (0) 2024</li>
</ul>



<p class="wp-block-paragraph">Explosive Matter (1), Gentle Star (1), Quite Easy (1) och Trixton (1) har sin första finalist som morfar. </p>



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



<p class="has-drop-cap wp-block-paragraph">Segerlös i sju starter som treåring. Fem vinster på sex försök i år. Adrian Kolgjini-tränade <strong>Love This Bar</strong> (e. Django Riff) står inför sitt livs i särklass största uppgift sedan hon via seger i försöket tagit sig till Derbystoet på hemmaplan.</p>



<p class="wp-block-paragraph">Med 290.500 kronor på kontot tillhör Love This Bar de fattigaste stona i fältet, men en konkurrent har tjänat mindre inför dagens jakt på två miljoner kronor. Philip di Lucas <strong>Juni Brick</strong> (e. Nuncio) har vunnit tre av 13 lopp och sprungit in 229.000 kronor så här långt.</p>



<p class="wp-block-paragraph">Rikast i fältet är <strong>Screen Time Limit</strong> (e. Face Time Bourbon) med 4.889.500 kronor på kontot, men även <strong>Vivillion</strong> (e. Propulsion) och <strong>S.G.Empress</strong> (e. Readly Express) har sprungit in över 4,5 miljoner kronor.</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/06/robertberghsulky-617x333.jpg" alt="" class="wp-image-732831"/><figcaption class="wp-element-caption">Robert Bergh. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">För 44.000 kronor klickade Robert Bergh hem <strong>Zucchini C.D.</strong> (e. Uncle Lasse) för hästägaren Johan Jonsson Invest AB:s räkning på en Traveraauktion i oktober förra året. Då hade hästen vunnit en av elva starter. Elva månader senare har hon fyllt på med fyra vinster på tio försök – och finalplats i Derbystoet efter att ha slutat tvåa i uttagningsloppet.</p>



<p class="wp-block-paragraph">Zucchini C.D. är också ensam av finalisterna att ha bytt ägare på en ettåringsauktion även om flera har varit uppe i ringen.</p>



<p class="wp-block-paragraph"><strong>Tangerina</strong> ropades åter på tyska Derbyauktionen för 14.000 euro som ettåring. Hon såldes sedan på Travera som treåring. <strong>Juni Brick </strong>ropades åter på Kriterieauktionen för 100.000 kronor. <strong>Tintarella</strong> ropades åter på Åby Yearling Sale för 80.000 kronor. Hon var också ett återrop på Travera i april i år för 940.000 kronor.</p>



<p class="wp-block-paragraph"><strong>Derbystohästarnas priser på auktion:</strong></p>



<ul class="wp-block-list">
<li>Zucchini C.D. – Kriterieauktionen – 130.000 kr</li>



<li>Zucchini C.D. – Travera – 44.000 kr</li>



<li>Tangerina* – Travera – 110.000 kr</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">Örjan Kihlström är kuskdominanten i Derbystoet. Fem gånger har han suttit bakom vinnaren, däribland både 2020 och 2021. Nu sitter han upp bakom Marcus Schön-tränade <strong>Love Bites</strong> (e. Greenshoe).<br>Jorma Kontio saknas bland kuskarna i årets final, men kan se tillbaka på fyra vinster i loppet. Johnny Takter, Åke Svanstedt och Peter Untersteiner ståtar med tre segrar vardera.</p>



<p class="wp-block-paragraph">Vid sidan om Kihlström har både Rikard N Skoglund och Carl Johan Jepson av årets finalkuskar vunnit tidigare. Rikard segrade med Mattias Djuse-tränade <strong>Racing Brodda</strong> (e. Prodigious) 2019 och kör nu för sjätte gången i rad <strong>S.G.Empress</strong> (e. Readly Express) för Roger Walmann.<br>Jepson rattade 2023 års vinnare <strong>Global Dancer</strong> (e. Carat Williams) åt Fredrik Wallin. Nu sitter han upp bakom Ulf Stenströmers <strong>Tangerina</strong> (e. Perfect Spirit).</p>



<p class="wp-block-paragraph"><strong>Örjan Kihlströms vinnare i Derbystoet:</strong><br><em>Häst (far) – År – Tränare</em></p>



<ul class="wp-block-list">
<li><strong>Handbag</strong> (e. Ditka Hanover) 1994 – Roger Walmann</li>



<li><strong>Pine Princess</strong> (e. Napoletano) 1999 – Nils Sylvén (a)</li>



<li><strong>Calamara Donna</strong> (e. Pine Chip) 2009 – Roger Walmann</li>



<li><strong>Diana Zet</strong> (e. Hard Livin) 2020 – Daniel Redén</li>



<li><strong>Honey Mearas</strong> (e. Readly Express) 2021 – Daniel Redén</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">Ann-Christin Lorentzon och John-Erik Magnusson är störst i historien vad gäller uppfödare till vinnare av Derbystoet. Tre av loppets 31 vinnare så här långt föddes upp i parets regi. Först ut var <strong>Nilema Pearl</strong> (e. Texas) 1993 och innan 1990-talet var över hade även <strong>Princip Ås</strong> (e. Mack Lobell) 1996 och <strong>Mack Action Ås </strong>(e. Mack Lobell) 1998 segrat i fyraåringsloppet.</p>



<p class="wp-block-paragraph">Finska bröderna Hannu och Mikko Laakkonen har firat stora framgångar med sin lilla kull ston födda 2021, där tre av dem var finalister i Svenskt Trav-Oaks med <strong>Vivillion</strong> (e. Propulsion) i topp, medan <strong>Screen Time Limit</strong> (e. Face Time Bourbon) vann långa E3. Duon är båda med i finalen av Derbystoet i regi Daniel Wäjersten.</p>



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



<ul class="wp-block-list">
<li>Love This Bar – Ilboängs Mark o Trav HB, Sala</li>



<li>Elegance Silvio – Stall Silvio AB, Åstorp</li>



<li>Tangerina – Lina Alm, Klågerup</li>



<li>S.G. Empress – Skärgården Stuteri AB, Väddö</li>



<li>Ulaya – Günter Herz, Tyskland</li>



<li>Giraffa – Annemanna AB, Ekerö</li>



<li>Vivillion – Ravitalli H Laakkonen Oy &#038; ML Stable Oy</li>



<li>Zucchini C.D. – Skråmsta Stuteri AB, Bro</li>



<li>Screen Time Limit – Ravitalli H Laakkonen Oy &#038; ML Stable Oy </li>



<li>Love Bites – Am Bloodstock AB, Stockholm</li>



<li>Juni Brick – Anders Bredberg, Tystberga</li>



<li>Tintarella – Bord 18 HB, Gunnilse</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/giraffamem250720adamstromstalltz-617x431.jpg" alt="" class="wp-image-754082"/><figcaption class="wp-element-caption">Giraffa. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Stall Zet är ensam om två segrar som hästägare i Derbystoet efter Diana Zets och Honey Mearas triumfer, men stallet saknar finalist i årets upplaga. Ingen av ägarkonstellationerna bakom de tolv Derbystohästarna har faktiskt tidigare segrat i loppet.</p>



<p class="wp-block-paragraph">Ägarna bakom hela åtta av finalisterna har varit med ”hela vägen” med sina ston. Som uppfödare och ägare. Elegance Silvio, S.G.Empress, Ulaya, Giraffa, Vivillion, Screen Time Limit, Love Bites och Juni Brick ägs nämligen fortsatt av sina uppfödare!</p>



<p class="wp-block-paragraph"><strong>Häst – Ägare</strong></p>



<ul class="wp-block-list">
<li>Love This Bar – Stall Courant AB, Heby</li>



<li>Elegance Silvio – Stall Silvio AB, Åstorp</li>



<li>Tangerina – Lars Lindberg Försäljning KB,Mariestad</li>



<li>S.G. Empress – Skärgården Stuteri AB, Väddö</li>



<li>Ulaya – Günter Herz, Tyskland</li>



<li>Giraffa – Annemanna AB, Ekerö</li>



<li>Vivillion – Ravitalli H Laakkonen Oy &#038; ML Stable Oy</li>



<li>Zucchini C.D. – Johan Jonsson Invest AB, Sundsvall</li>



<li>Screen Time Limit – Ravitalli H Laakkonen Oy &#038; ML Stable Oy</li>



<li>Love Bites – Stall Courant AB, Heby</li>



<li>Juni Brick – Norrby Säteri AB, Tystberga</li>



<li>Tintarella – Jasmi Friman, Finland</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">Malin Boman-Friberg har skött många topphästar genom åren hos Roger Walmann och framför allt sticker superstoet <strong>Giant Diablo</strong> (e. Supergill) ut. Hon tävlade ”på sin tid” på Derbydagen på Jägersro, men någon seger i Derbystoet blev det inte. Walmann spänade bågen och tog ut stoet mot hingstarna i Svenskt Travderby och det var sånär att det lyckades. Giant Diablo slutade nämligen tvåa bakom Gazza Degato (e. Alf Palema) i 2004 års upplaga av travets blå band.</p>



<p class="wp-block-paragraph">Idag kan Malin däremot ta en skötarseger i Derbystoet, då hennes passhäst S.G.Empress finns med i startfältet.</p>



<p class="wp-block-paragraph"><strong>Häst – Skötare</strong></p>



<ul class="wp-block-list">
<li>Love This Bar – Saga Scott</li>



<li>Elegance Silvio – Jeanette Klasson</li>



<li>Tangerina – Maria Wedell</li>



<li>S.G. Empress – Malin Boman-Friberg</li>



<li>Ulaya – Saara Jaakonsaari</li>



<li>Giraffa – TiinaKaunisaho</li>



<li>Vivillion – Ebba Karbelius</li>



<li>Zucchini C.D. – Philip Björk</li>



<li>Screen Time Limit – Marja Ahonen</li>



<li>Love Bites – Thilde Larsson</li>



<li>Juni Brick – Justine Delepine</li>



<li>Tintarella – Hannah Matikainen</li>
</ul>


<div class="factbox full ">
<div class="insidefactbox">
<div class="overflow">
<div class="height">
<div class="padding">
<div class="factvinjett">Fakta</div>
<h3 class="title">
									Alla vinnare av Derbystoet								</h3>
<div class="content">
<p class="wp-block-paragraph"><strong>År: Vinnare – Far/mor – Kusk (tränare) – Segertid</strong></p>
<p class="wp-block-paragraph">1991: <strong>Charm Patricia</strong> – e. Keystone Patriot-Charm Limit&nbsp; – Stefan Erlandsson (Rainer Ström) – 1.15,7a</p>
<p class="wp-block-paragraph">1992: <strong>Note Broline</strong> – e. Nuclear Kosmos-Harmony Broline – Stig H Johansson – 1.15,7a&nbsp;</p>
<p class="wp-block-paragraph">1993: <strong>Nilema Pearl</strong> – e. Texas-Nevele Duchess&nbsp; – Johnny Takter (Hans Adielsson) – 1.15,3a&nbsp;</p>
<p class="wp-block-paragraph">1994: <strong>Handbag</strong> – e. Ditka Hanover-Trader Girl – Örjan Kihlström (Roger Walmann) – 1.15,5a&nbsp;</p>
<p class="wp-block-paragraph">1995: <strong>Balcony I.T.</strong> – e. Valley Victory-Overexposed&nbsp; – Stig H Johansson – 1.16,1a&nbsp;</p>
<p class="wp-block-paragraph">1996: <strong>Princip Ås</strong> – e. Mack Lobell-U.S.Principessa&nbsp; – Lennart Forsgren (Atle Hamre) – 1.16,1a&nbsp;</p>
<p class="wp-block-paragraph">1997: <strong>Blue Bahia</strong> – e. Meadow Gallant-Chanell Quick&nbsp; – Bo Eklöf (Roine Andersson) – 1.15,6a&nbsp;</p>
<p class="wp-block-paragraph">1998: <strong>Mack Action Ås</strong> – e. Mack Lobell-Around the Action&nbsp; – Olle Goop – 1.14,6a&nbsp;</p>
<p class="wp-block-paragraph">1999: <strong>Pine Princess</strong> – e. Napoletano-Working Woman – Örjan Kihlström (Nils Sylvén) – 1.15,2a&nbsp;</p>
<p class="wp-block-paragraph">2000: <strong>Miss Pilaar</strong> – e. Super Arnie-Torinos Sweet L. – Erik Adielsson (Stig H Johansson) – 1.15,0a&nbsp;</p>
<p class="wp-block-paragraph">2001: <strong>Yatzy Brodda</strong> – e. Alf Palema-Yvonne M. – Jorma Kontio (Stefan Melander) – 1.14,3a&nbsp;</p>
<p class="wp-block-paragraph">2002: <strong>Eli Sea</strong> – e. Running Sea-Erva Split – Rauno Pöllänen (Lennart Mossberg) – 1.14,3a&nbsp;</p>
<p class="wp-block-paragraph">2003: <strong>Je T’aime Dream</strong> – e. Sugarcane Hanover-J’aime Hornline&nbsp; – Jorma Kontio (Stig H Johansson) – 1.14,5a&nbsp;</p>
<p class="wp-block-paragraph">2004: <strong>Minnesota</strong> – e. Spotlite Lobell-Cosima D.&nbsp; – Åke Svanstedt – 1.14,1a&nbsp;</p>
<p class="wp-block-paragraph">2005: <strong>Fama Currit</strong> – e. Viking Kronos-Union Madigan&nbsp; – Peter Ingves (Petri Puro) – 1.14,1a&nbsp;</p>
<p class="wp-block-paragraph">2006: <strong>Patricia du Ling</strong> – e. Super Arnie-Precious du Ling&nbsp; – Jorma Kontio (Timo Nurmos) – 1.14,9a&nbsp;</p>
<p class="wp-block-paragraph">2007: <strong>Stargirl</strong> – e. Juliano Star-All American Girl&nbsp; – Åke Svanstedt – 1.14,4a&nbsp;</p>
<p class="wp-block-paragraph">2008: <strong>Bobtail</strong> – e. Juliano Star-Miss Pilaar – Erik Adielsson (Stig H Johansson) – 1.13,4a&nbsp;</p>
<p class="wp-block-paragraph">2009: <strong>Calamara Donna</strong> – e. Pine Chip-Frosts Octopussy – Örjan Kihlström (Roger Walmann) – 1.13,7a&nbsp;</p>
<p class="wp-block-paragraph">2010: <strong>Viola Silas</strong> – e. Lindy Lane-Iza Silas&nbsp; – Fredrik Persson – 1.12,7a&nbsp;</p>
<p class="wp-block-paragraph">2011: <strong>Nettan Palema</strong> – e. Gidde Palema-Hanna Hebre&nbsp; – Åke Svanstedt – 1.13,4&nbsp;</p>
<p class="wp-block-paragraph">2012: <strong>Red Red Red</strong> – e. Offshore Dream-Extreme Lady&nbsp; – Fredrik Persson – 1.12,2a&nbsp;</p>
<p class="wp-block-paragraph">2013: <strong>Fascination</strong> – e. Super Arnie-Elissa F.Z.&nbsp; – Johnny Takter (Lars I Nilsson) – 1.13,7a&nbsp;</p>
<p class="wp-block-paragraph">2014: <strong>Neona Princess</strong> – e. Gigant Neo-Dew Princess&nbsp; – Peter Untersteiner – 1.13,2a&nbsp;</p>
<p class="wp-block-paragraph">2015: <strong>Evin Boko</strong> – e. Viking Kronos-Welat Boko – Jorma Kontio (Timo Nurmos) – 1.13,1a&nbsp;</p>
<p class="wp-block-paragraph">2016: <strong>Otrobanda</strong> – e. Celebrity Secret-Greenhill’s Beauty – Peter Untersteiner – 1.12,9a&nbsp;</p>
<p class="wp-block-paragraph">2017: <strong>Cash Crowe</strong> – e. Ready Cash-Giant Crowe – Johnny Takter (Petri Puro) – 1.11,6a&nbsp;</p>
<p class="wp-block-paragraph">2018: <strong>Run Chica Run</strong> – e. Scarlet Knight-Run Baby Run – Peter Untersteiner – 1.12,0a&nbsp;</p>
<p class="wp-block-paragraph">2019: <strong>Racing Brodda</strong> – e. Prodigious-Ronda Brick – Rikard N Skoglund (Mattias Djuse) – 1.12,1a&nbsp;</p>
<p class="wp-block-paragraph">2020: <strong>Diana Zet</strong> – e. Hard Livin-Marsia L.B. – Örjan Kihlström (Daniel Redén) – 1.12,7a&nbsp;</p>
<p class="wp-block-paragraph">2021: <strong>Honey Mearas</strong> – e. Readly Express-Khao Manee – Örjan Kihlström (Daniel Redén) – 1.11,5a&nbsp;</p>
<p class="wp-block-paragraph">2022: <strong>Lara Boko</strong> – e. Djali Boko-Pecadille Face – Mika Forss (Timo Nurmos) – 1.11,9a&nbsp;</p>
<p class="wp-block-paragraph">2023: <strong>Global Dancer</strong> – e. Carat Williams-Balett Sund – Carl Johan Jepson (Fredrik Wallin) –&nbsp;1.12,1a</p>
<p class="wp-block-paragraph">2024: <strong>Daim Brodda</strong> – e. Realdy Express-Dancing In Thehall – Eirik Höitomt (Thor Borg) – 1.11,9a</p>
<p class="wp-block-paragraph">2025: <strong>S.G.Empress</strong> – e. Readly Express-Riva del Sole – Rikard N Skoglund (Roger Walmann) – 1.12,1a</p>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
