
<p class="has-drop-cap">Derbystoets finalister samlas på få händer när det gäller tränarna 2023. Johan Untersteiner, Timo Nurmos (tre vardera) och Daniel Redén (två) står bakom åtta av finalisterna, medan Jörgen Westholm, Paul Hagoort, Fredrik Wallin och Roger Walmann tränar en häst vardera.</p>



<p>Förra året skrev Nurmos historia när han var mannen bakom halva finalfältet – sex av tolv ston! Det är rekord i Derbystoet och slutade med dubbelseger för Solvallatränaren när kulldrottningen <strong>Lara Boko</strong> (e. Djali Boko) segrade före <strong>Senorita Tokio</strong> (e. Southwind Frank). Nurmos har även kunnat räkna in vinster för <strong>Patricia du Ling</strong> (e. Super Arnie) 2006 och <strong>Evin Boko</strong> (e. Viking Kronos) 2015, båda med Jorma Kontio som tömförare.<br>Nurmos finaltrio i år är <strong>Jennifer Sisu </strong>(e. Propulsion), <strong>Aurelia Express</strong> (e. Readly Express) och <strong>Bonneville W.I.</strong> (e. S.J.’s Caviar) som alla vann sina uttagningslopp.</p>



<p>Två tränare har lyckats med konststycket att ha fem finalister samma år: Stig H Johansson och Peter Untersteiner. Medan Stig H fick nöja sig med en tredjeplats som bäst i finalen, så tog Untersteiner en dubbel genom <strong>Run Chica Run</strong> (e. Scarlet Knight) och <strong>Europhile Am</strong> (e. Gift Kronos).</p>



<p><strong>Flest finalister samma år i Derbystoet:</strong><br><em>Tränare, år – Antal – Bästa placering</em></p>



<ul class="wp-block-list">
<li>Timo Nurmos 2022 – 6 – Lara Boko etta</li>



<li>Stig H Johansson 2005 – 5 – Toamasina trea</li>



<li>Peter Untersteiner 2018 – 5 – Run Chica Run etta</li>



<li>Olle Goop 1997 – 4 – Carolinas Mystic tvåa</li>



<li>Roger Walmann 2014 – 4 – D’One tvåa</li>



<li>Daniel Redén 2020 – 4 – Diana Zet etta</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/2022/09/queenbelina-617x333.jpg" alt="" class="wp-image-352679"/><figcaption class="wp-element-caption">Queen Belina. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



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



<p><strong>Priser:</strong> 2.000.000-1.000.000-500.000-240.000-160.000-100.000 kr.<br><em>2.140 meter, autostart.</em><br><strong>Namn (far) – Kusk (tränare)</strong></p>



<ol class="wp-block-list">
<li><strong>Mi Amore Bros </strong>(e. Propulsion) – Rikard N Skoglund (Daniel Redén)</li>



<li><strong>Queen Belina</strong> (e. Nuncio) – Örjan Kihlström (Jörgen Westholm)</li>



<li><strong>Julia Sisu </strong>(e. Kadabra) – Robin Bakker (Paul Hagoort)</li>



<li><strong>Jennifer Sisu </strong>(e. Propulsion) – Magnus A Djuse (Timo Nurmos)</li>



<li><strong>Aurelia Express</strong> (e. Readly Express) – Mats E Djuse (Timo Nurmos)</li>



<li><strong>Mary Ann Lane</strong> (e. Orlando Vici) – Johan Utersteiner</li>



<li><strong>Global Dancer</strong> (e. Carat Williams) – Carl Johan Jepson (Fredrik Wallin)</li>



<li><strong>Wonderful Tonight</strong> (e. Magic Tonight) – Thomas Uhrberg (Roger Walmann)</li>



<li><strong>Bonneville W.I.</strong> (e. S.J.’s Caviar) – Björn Goop (Timo Nurmos)</li>



<li><strong>Bikana Wine </strong>(e. Propulsion) – Stefan Persson (Johan Untersteiner)</li>



<li><strong>Mahala</strong> (e. Propulsion) – Ulf Ohlsson (Daniel Redén)</li>



<li><strong>Mellby Korall </strong>(e. Maharajah) – Peter Untersteiner (Johan Untersteiner)</li>
</ol>



<p>*Samtliga hästar ingår i premiechansen och tävlar om dubbla prispengarna i Derbystoet. </p>



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



<p class="has-drop-cap">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>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.<br>Lika många har alltså Timo Nurmos, som kan kliva upp på ensam andraplats vid seger under söndagen.</p>



<p>Derbystoet kördes första gången 1991, då Stefan Erlandsson med Rainer Ström-tränade <strong>Charm Patricia</strong> (e. Keystone Patriot).</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/12/propulsionmlad13-617x333.jpg" alt="" class="wp-image-35770"/><figcaption class="wp-element-caption">Propulsion. Foto Jeannie Karlsson/Sulkysport</figcaption></figure>



<p class="has-drop-cap">2019 föddes Propulsions första kull och den består av 61 svenskfödda avkommor. 30 av dem är ston – och fyra av dessa finns med i Derbystoet! Mest meriterad i sällskapet är dubbelmiljonärskan <strong>Jennifer Sisu</strong>.<br>Propulsion huserar numera på finsk mark och ur hans debutkull finns även fjolårets svenske Kriterievinnare <strong>Xanthis Harvey</strong>.</p>



<p>Av fäderna till årets hästar i Derbystoet är det bara fyra hingstar som haft startande avkommor tidigare i loppet. Readly Express, som mönstrar dottern <strong>Aurelia Express</strong> (e. Readly Express), är ensam om att ha lämnat en vinnare tidigare i Honey Mearas som segrade för två år sedan. Maharajah har varit flitigaste finaldeltagaren med nio tidigare finalister men väntar fortfarande på första segern. I år ställs hoppet till <strong>Mellby Korall </strong>(e. Maharajah).</p>



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



<p><em>Avelshingst (antal avkommor) – Tidigare finalister</em></p>



<ul class="wp-block-list">
<li><strong>Kadabra</strong> (1) – 1 – Wingait Ida (0) 2014</li>



<li><strong>Maharajah</strong> (1) – 9 – 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 Lame (6) 2020, Mellby Harissa (0) 2020, Juni Rapid (5) 2021</li>



<li><strong>Readly Express</strong> (1) – 2 – Honey Mearas (1) 2021, Tilda Express (0) 2021</li>



<li><strong>S.J.’s Caviar</strong> (1) – 6 – Caviar’s Goldcard (0) 2013, Global Upper Style (4) 2018, Conrads Rödluva (2) 2019, Staro Miami (0) 2019, Global Brilliance (2) 2021, Rihanna W.I. (0) 2022</li>
</ul>



<p>Carat Williams (1), Magic Tonight (1), Nuncio (1), Orlando Vici (1) och Propulsion (4) har sina första startande avkommor i Derbystoet.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/09/bonnevillew.i.6-617x333.jpg" alt="" class="wp-image-358767"/><figcaption class="wp-element-caption">Bonneville W.I. vann Svenskt Trav-Oaks före Aurelia Express. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap"><strong>Bonneville W.I.</strong> (e. S.J.’s Caviar) vann stallduellen mot <strong>Aurelia Express</strong> (e. Readly Express) i Svenskt Trav-Oaks förra hösten och nu drabbar Timo Nurmos toppston samman i en ny final. Skulle Bonneville W.I. lyckas vinna loppet sällar hon sig till en fin skara ston som tagit hem både Oaks och Derbystoet.</p>



<p>Att ta dubbeln är inte speciellt vanligt. Det har hänt fem gånger i loppets drygt 30-åriga historia och senast i raden är fjolårsvinnaren Lara Boko (e. Djali Boko). </p>



<p><strong>Ston som tagit dubbeln Oaks och Derbystoet:</strong></p>



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



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



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



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



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



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



<p class="has-drop-cap">Halva fältet ståtar med sjusiffrig startprissumma, där två av stona dessutom klivit över tre miljoner kronor intjänat. <strong>Bonneville W.I. </strong>(e. S.J.’s Caviar) toppar med 3.194.000 kronor och skuggas närmast av Jörgen Westholms <strong>Queen Belina</strong> (e. Nuncio). </p>



<p>Queen Belina är Jörgens fjärde finalist i Derbystoet och hans absolut största chans på förhand. Tidigare har det gått som bäst för <strong>Ninepoints Lucy</strong> (e. Deweycheatumnhowe), som slutade femma 2014.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/07/juliasisurbd230706adamstromstalltz-1-617x413.jpg" alt="" class="wp-image-467737"/><figcaption class="wp-element-caption">Julia Sisu vann Stosprintern. Foto  Adam Ström/StallTZ.se.</figcaption></figure>



<p class="has-drop-cap">Pallplats i Sveriges största tvååringslopp och vinst i Stosprintern knappt två år senare. <strong>Julia Sisu</strong> (e. Kadabra) visade hög kapacitet redan första tävlingssäsongen i regi Per Nordström, där sex starter (2-1-2) inbringade över halvmiljonen kronor. <br>Den summan har fyrdubblats sedan dess – framför allt tack vare triumfen i Stosprintern – för Julia Sisu som lämnade Nordströms stall förra sommaren och efter sejourer hos Rick Ebbinge och Wolfgang Nimczyk sedan i början av sommaren återfinns hos holländaren Paul Hagoort.</p>



<p>Ingen tränare med licens i utlandet har segrat i Derbystoet.</p>



<p><strong>Så här har det gått för Derbystohästarna i sina tidigare storloppsfinaler:</strong></p>



<ul class="wp-block-list">
<li>Mi Amore Bros – första storloppsfinalen</li>



<li>Queen Belina – etta i Breeders Crown, trea i Oaks, oplacerad i Stochampionatet</li>



<li>Julia Sisu – etta i Stosprintern, trea i Svenskt Uppfödningslöpning</li>



<li>Jennifer Sisu – tvåa i Stochampionatet och Stosprintern, oplacerad i Breeders Crown</li>



<li>Aurelia Express – tvåa i Oaks, femma i Stochampionatet och Breeders Crown</li>



<li>Mary Ann Lane – trea i Stochampionatet</li>



<li>Global Dancer – diskvalificerad i Stochampionatet och Stosprintern</li>



<li>Wonderful Tonight – första storloppsfinalen</li>



<li>Bonneville W.I. – etta i Oaks, diskvalificerad i Breeders Crown</li>



<li>Bikana Wine – första storloppsfinalen</li>



<li>Mahala – första storloppsfinalen</li>



<li>Mellby Korall – fyra i Drottningpokalen, diskvalificerad i Stosprintern</li>
</ul>



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



<p class="has-drop-cap">Finalister i Drottning Silvias Pokal, Stosprintern och Stochampionatet har Johan Untersteiner haft tidigare under säsongen. När de fyraåriga stona gör upp i Derbystoet är Johan förstås med igen – med tre hästar dessutom.</p>



<p><strong>Mary Ann Lane</strong> (e. Orlando Vici), som slutade trea i Stochampionatet är Johans egna val medan han lånar ut <strong>Bikana Wine</strong> (e. Propulsion) till Stefan Persson och <strong>Mellby Korall</strong> (e. Maharajah) till pappa Peter. Som kusk har Johan andraplatsen med Roger Walmann-tränade Stepping Space (e. Fast Photo) bakom Viola Silas i 2010-års upplaga som främsta resultat.</p>



<p><a href="https://sulkysport.se/kan-vinna-derbyt/" target="_blank" rel="noreferrer noopener">––> Så här säger Johan Untersteiner själv inför Derbyhelgen!</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/07/mahalaokm230701adamstromstalltz-617x404.jpg" alt="" class="wp-image-465428"/><figcaption class="wp-element-caption">Mahala ägs och är uppfödd av Daniel Redén. Foto Adam Ström/Stalltz.se</figcaption></figure>



<p class="has-drop-cap">2 segrar de tre senaste åren ståtar Stall Zet med som hästägare efter Diana Zets och Honey Mearas triumfer. Stall Zet är faktiskt ensam bland årets deltagare om att tidigare haft en vinnare i loppet som ägare när stallets hopp heter <strong>Mi Amore Bros</strong> (e. Propulsion).</p>



<p>Daniel Redén har själv en egenägd och egenuppfödd finalist genom sitt bolag Redén Trotting AB, nämligen <strong>Mahala</strong> (e. Propulsion).</p>



<h2 class="wp-block-heading">Hästägare i Derbystoet</h2>



<ol class="wp-block-list">
<li>Stall Zet (Daniel Redén) – Mi Amore Bros</li>



<li>Anders van Dapperen HB, Mellbystrand – Queen Belina</li>



<li>Stal Carpe Diem, Nederländerna – Julia Sisu</li>



<li>Stall 4C HB &#038; Stall Timo Nurmos AB – Jennifer Sisu</li>



<li>Stall Kennys Andelshästar 80 – Aurelia Express</li>



<li>Mats B Hansson Förvaltning AB – Mary Ann Lane</li>



<li>Ofcourse KB, Kovland – Global Dancer</li>



<li>Srf Stable – Wonderful Tonight</li>



<li>Wallén Invest i Västervik AB – Bonneville W.I.</li>



<li>Stall Ystadpågarna Easy – Bikana Wine</li>



<li>Redén Trotting AB, Örsundsbro – Mahala</li>



<li>Mellby Gård AB, Malmö – Mellby Korall</li>
</ol>



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



<p class="has-drop-cap">Roger Walmanns meritlista i svenska unghästlopp är lång, framför allt på stosidan. I Derbystosammanhang har han haft hela 28 finalister tidigare, men det har ”bara” blivit två triumfer. Redan 1994 kom den första med speedkulan <strong>Handbag</strong> (e. Ditka Hanover) och 2009 slog <strong>Calamara Donna</strong> (e. Pine Chip) till, båda med Örjan Kihlström i sulkyn.</p>



<p><strong>Wonderful Tonight</strong> (e. Magic Tonight) är Walmanns bidrag i år och hästen körs för första gången av Thomas Uhrberg. Duon kan med glädje se tillbaka på Derbydagen 2006. Då styrde nämligen Uhrberg in Walmann-tränade <strong>Colombian Necktie</strong> (e. Alf Palema) till seger i Svenskt Travderby!</p>



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



<p class="has-drop-cap">Blott en av de tolv finalisterna bytte ägare på auktion som ettåringar. Det handlar om <strong>Mi Amore Bros</strong> (e. Propulsion), som Stall Zet/Daniel Redén ropade in på Sweden International Yearling Sale 2020 för 190.000 kronor.</p>



<p><strong>Global Dancer</strong> (e. Carat Williams) såldes i slutet av förra sommaren som treåring 2022 på Traveras internetauktion för 760.000 kronor. </p>



<p><strong>Queen Belina</strong> ropades åter för 250.000 kronor på Kriterieauktionen 2020, <strong>Mary Ann Lane</strong> togs tillbaka för 140.000 kronor på Kriteriauktionen. <strong>Wonderful Tonight</strong> var struken på på Travera-auktion i år.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/07/joysisumfm230723adamstromstalltz-617x407.jpg" alt="" class="wp-image-474296"/><figcaption class="wp-element-caption">Joy Sisus seger och Jennifer Sisus andraplats i Stochampionatet var bingo för Brillantissime respektive Propulsion. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap">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>I årets final är Sisyfos Breeders AB, Sigtuna, ensam om att ha två uppfödningar till start: <strong>Julia Sisu</strong> (e. Kadabra) och <strong>Jennifer Sisu</strong> (e. Propulsion).</p>



<p>Sisyfos har redan plockat hem det största loppet för de fyraåriga stona när <strong>Joy Sisu</strong> (e. Brillantissime) vann Stochampionatet i somras. Joy Sisu missar dock Derbystoet, då hon slutade trea i uttagningsloppet. </p>



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



<ol class="wp-block-list">
<li>Bros Stables, Nederländerna – Mi Amore Bros</li>



<li>A &#038; H K Karlsson och Jörgen Westholm – Queen Belina</li>



<li>Sisyfos Breeders AB, Sigtuna – Julia Sisu</li>



<li>Sisyfos Breeders AB, Sigtuna – Jennifer Sisu</li>



<li>Nicolas de Mitri &#038; Sofia Blomberg – Aurelia Express</li>



<li>Prestera International AB, Limhamn – Mary Ann Lane</li>



<li>Global Farm AB, Nacka Strand – Global Dancer</li>



<li>AB Svensk Reklamfinans, Halmstad – Wonderful Tonight</li>



<li>Wallén Invest i Västervik AB – Bonneville W.I.</li>



<li>Peter Martinsson, Helsingborg – Bikana Wine</li>



<li>Redén Trotting AB, Örsundsbro – Mahala</li>



<li>Mellby Gård AB, Malmö – Mellby Korall</li>
</ol>



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



<p class="has-drop-cap">Ö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 Jörgen Westholm-tränade <strong>Queen Belina</strong> (e. Nuncio) som han firat framgångar med tidigare, framför allt vid segern i Breeders Crown-finalen för treåriga ston förra hösten.</p>



<p>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 och Untersteiner har chansen att utöka då han kör sonen Johans <strong>Mellby Korall</strong> (e. Maharajah).</p>



<p>Vid sidan om Kihlström och Untersteiner har även Rikard N Skoglund av årets finalkuskar vunnit tidigare. 2019 styrde han nyligen pensionerade Racing Brodde (e. Prodigious) till vinst.</p>



<p><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">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/09/globaldancermadm220923adamstromstalltz-617x360.jpg" alt="" class="wp-image-358650"/><figcaption class="wp-element-caption">Global Dancer vann E3 Revanschen för ston. Foto Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap">Bara två av tolv hästar tävlade som tvååringar. Det handlar om nämnda Uppfödningslopptrean <strong>Julia Sisu</strong> (e. Kadabra) och Fredrik Wallins <strong>Global Dancer</strong> (e. Carat Williams).</p>



<p>Medan Julia Sisu drog in 524.830 kronor ”nöjde sig” Global Dancer med 49.000 kronor på fem starter (1-0-0). Segern togs dock på fina 1.14,8a/1.640 meter i ett försök till Norrlands Elitserie i Bollnäs i livets tredje start.<br>Global Dancer är också den häst som startat flitigast. 25 starter har det blivit för Fredrik Wallins sto, tre fler än Roger Walmann-tränade <strong>Wonderful Tonight</strong> (e. Magic Tonight).</p>



<p>I andra änden finns Daniel Redéns duo <strong>Mahala</strong> (e. Propulsion) och <strong>Mi Amore Bros</strong> (e. Propulsion) med elva respektive tolv starter i kroppen.</p>



<p>***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/02/bikanawinejum230204adamstromstalltz-617x397.jpg" alt="" class="wp-image-407373"/><figcaption class="wp-element-caption">Bikana Wine spurtade till vinst i Margaretas Tidiga Unghästserie i februari. Foto Adam Ström/stlltz.se</figcaption></figure>



<p class="has-drop-cap">Super Arnie är en av de bästa avelshingstarna som verkat på svensk mark och plockade hem hingstchampionatet fyra år i rad 2006–2009. Som morfar fortsatte framgångarna och fyra titlar har han räknat in i den kategorin: 2010, 2011, 2013 och 2014.<br>Hans blod lever vidare i högsta grad och Super Arnie är morfar till <strong>Bikana Wine</strong> (e. Propulsion), som kan ordna superhingstens fjärde (!) triumf som morfar. Tidigare har Bobtail, Run Chica Run och Racing Brodda vunnit Derbystoet.</p>



<p>Förutom Super Arnie har även Muscle Hill av årets morfarshingstar en vinnare i lopphistorien, detta genom fjolårsvinnaren Lara Boko. Årets bidrag är <strong>Julia Sisu</strong> (e. Kadabra). </p>



<p><strong>Morfädernas resultat i Derbyt:</strong><br><em>Morfar (antal avkommor) – Tidigare finalister</em></p>



<ul class="wp-block-list">
<li><strong>Credit Winner</strong> (1) – 2 – Flo Jo Keeper (5) 2017, Eagle Eye Sherry (0) 2021</li>



<li><strong>Muscle Hill</strong> (1) – 2 – <strong>Lara Boko</strong> (1) 2022, Glorious Rain (3) 2022</li>



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



<li><strong>Super Arnie</strong> (1) – 11 – Kings Any (3) 2004, Alltid V.G. (0) 2006, <strong>Bobtail</strong> (1) 2008, Paper Moon (6) 2008, Queen of Rock (5) 2009, Donna Lyjam (0) 2015, Tunika (3) 2016, Timbal (0) 2016, <strong>Run Chica Run</strong> (1) 2018, <strong>Racing Brodda</strong> (1) 2019, Isabelle Cash (0) 2022</li>



<li><strong>Varenne</strong> (1) – 3 – Uncertain Age (6) 2017, Heloise Am (0) 2021, Senorita Tokio (2) 2022</li>



<li><strong>Zola Boko</strong> (1) – 1 – Rihanna W.I. (0) 2022</li>
</ul>



<p>Celebrity Secret (1), Make It Happen (1), Ready Cash (2) och Toss Out (1) debuterar som morfar i Derbystoet. </p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/09/bonnevillew.i.rebeccasjoberg-617x333.jpg" alt="" class="wp-image-490980"/><figcaption class="wp-element-caption">Fjolårets Oaksvinnare Bonneville W.I. är en av Rebecca Sjöbergs två starthästar i Derbystoet. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Rebecca Sjöberg, anställd hos Timo Nurmos, får ha blicken åt två håll i Derbystoet. Rebecca är nämligen skötare till dubbla finalister. Rebecca fanns på sidlinjen redan i fjolårets final när hennes passhäst <strong>Rihanna W.I.</strong> (e. S.J.’s Caviar) startade. Nu ställer hon hoppet till lillasystern <strong>Bonneville W.I. </strong>(e. S.J.’s Caviar) och <strong>Jennifer Sisu</strong> (e. Propulsion).</p>



<p><strong>Skötare i Derbystoet:</strong></p>



<ul class="wp-block-list">
<li>Michaela Magnusson – Mi Amore Bros</li>



<li>Jenny Martinsson – Queen Belina</li>



<li>Demi Veenstra – Julia Sisu</li>



<li>Rebecca Sjöberg – Jennifer Sisu</li>



<li>Karariina Nurmonen – Aurelia Express</li>



<li>Josefine Jenssen – Mary Ann Lane</li>



<li>Annsofie Bergfeldt – Global Dancer</li>



<li>Wilma Friberg – Wonderful Tonight</li>



<li>Rebecca Sjöberg – Bonneville W.I.</li>



<li>Jenny Nilsson – Bikana Wine</li>



<li>Jenny Sundin – Mahala</li>



<li>Eva Boel – Mellby Korall</li>
</ul>



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



<p class="has-drop-cap">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>De åtta senaste vinnarna av loppet har alla varit premiechansade och fått dubbla prischecken.</p>


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