
<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 och ställer sitt hopp till <strong>Carmita Silvio</strong> (e. Maharajah) idag.<br>Lika många har Timo Nurmos, som kan kliva upp på ensam andraplats vid seger under söndagen för hans hopp <strong>Granger</strong> (e. Trixton). <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/2024/08/knickerssisumedm240820adamstromstalltz-617x388.jpg" alt="" class="wp-image-624253"/><figcaption class="wp-element-caption">Knickers Sisu och Mats E Djuse vid segern i uttagningsloppet till Derbystoet. Foto Adam Ström/Stalltz.se</figcaption></figure>



<p>Förutom Timo Nurmos vet ytterligare fyra av tränarna bakom dagens finalister hur det känns att vinna Derbystoet. <br>Roger Walmann har två titlar. Den första kom redan 1994 med <strong>Handbag</strong>, medan seger två dröjde 15 år till 2009 när <strong>Calamara Donna</strong> triumferade. <strong>Kelly Smartface</strong> (e. Captain Sparrow) är hästen som kan ordna en tredje titel.<br>Mattias Djuse vann loppet 2019 med <strong>Racing Brodda</strong> och har dubbla chanser att fördubbla segerskörden i miljonloppet. Detta genom försöksvinnaren <strong>Knickers Sisu</strong> (e. Southwind Frank) och <strong>Dial Square</strong> (e. Ready Cash).</p>



<p><a href="https://sulkysport.se/dubbelt-djuse-i-derbystoet-bra-feeling/" target="_blank" rel="noreferrer noopener">––> Så här säger Mattias Djuse inför dagens storloppsfinal!</a></p>



<p>Två chanser har också Gävletränaren Fredrik Wallin, som förra året spräckte segernollan i Derbystoet när <strong>Global Dancer</strong> (e. Carat Williams) segrade tillsammans med Carl Johan Jepson. Försökstvåorna <strong>Pure Diamond</strong> (e. Father Patrick) och <strong>Caia</strong> (e. Cantab Hall) mönstrar Wallin idag.<br>Hemmatränaren Lars I Nilssons fenomenala sto <strong>Fascination</strong> (e. Super Arnie) skördade stora framgångar som unghäst och i hennes digra meritlista finns även seger i Derbystoet. 2013 togs den tillsammans med Johnny Takter. Nu är Lars I tillbaka med <strong>Flamenco Girl</strong> (e. Maharajah).</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>



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



<p><strong>2.140 meter, autostart.</strong><br><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li>Sonesta (e. Bold Eagle) – Jörgen Westholm </li>



<li>Daim Brodda (e. Readly Express) – Eirik Höitomt (Thor Borg)</li>



<li>Kelly Smartface (e. Captain Sparrow) – Örjan Kihlström (Roger Walmann)</li>



<li>Countess Face (e. Muscle Hill) – Adrian Kolgjini</li>



<li>Knickers Sisu (e. Southwind Frank) – Mats E Djuse (Mattias Djuse)</li>



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



<li>Pure Diamond (e. Father Patrick) – Carl Johan Jepson (Fredrik Wallin)</li>



<li>Caia (e. Cantab Hall) – Santtu Raitala (Fredrik Wallin)</li>



<li>Xia Lloyd (e. Raja Mirchi) – Dante Kolgjini (Adrian Kolgjini)</li>



<li>Flamenco Girl (e. Maharajah) – Stefan Persson (Lars I Nilsson)</li>



<li>Dial Square (e. Ready Cash) – Magnus A Djuse (Mattias Djuse)</li>



<li>Granger (e. Trixton) – Björn Goop (Timo Nurmos)</li>
</ol>



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



<p class="has-drop-cap">För åtta år sedan plockade Peter Untersteiner hem Derbystoet med <strong>Otrobanda</strong> (e. Celebrity Secret), 1.12,1am*/3.026.000 kr, från ledningen med ett (1) på nummerbrickan. Nu kan hennes dotter <strong>Sonesta</strong> (e. Bold Eagle) göra samma sak – från samma startspår.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/08/sonestamadm240820adamstromstalltz-617x409.jpg" alt="" class="wp-image-624200"/><figcaption class="wp-element-caption">Sonesta. Foto Adam Ström/Stalltz.se</figcaption></figure>



<p>Jörgen Westholm tränar och kör Sonesta som var nära att kvala in till Stochampionatet, men slutade trea i sitt uttagningslopp. I försöken till Derbystoet gick det desto bättre och med Magnus A Djuse i sulkyn ordnade hon finalplatsen via seger.<br>Nu hoppar tränare Westholm själv upp i sulkyn i finalen och Jörgen kan bland annat se tillbaka på kusk- och tränarseger i långa E3 med <strong>Dream Mine</strong> (e. Maharajah) tidigare i sommar.</p>



<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 Roger Walmann-tränade <strong>Kelly Smartface</strong> (e. Captain Sparrow).<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>Vid sidan om Kihlström har enbart Carl Johan Jepson av årets finalkuskar vunnit tidigare. Han rattade fjolårets vinnare <strong>Global Dancer</strong> (e. Carat Williams) åt Fredrik Wallin och samme tränare är mannen bakom Jepsons uppsittning idag, Pure Diamond (e. Father Patrick).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/08/kellysmartfaceokh240820adamstromstalltz-617x388.jpg" alt="" class="wp-image-624198"/><figcaption class="wp-element-caption">Kelly Smartface. Foto Adam Ström/stalltz.se</figcaption></figure>



<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>Handbag (e. Ditka Hanover) 1994 – Roger Walmann</li>



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



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



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



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



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



<p class="has-drop-cap">Oavsett vem som tar hem Derbystoet så kommer vinnarens bankbok att mer än fördubblats. Ingen av de tolv finalisterna har passerat förstapriset två miljoner kronor hittills i karriären.<br>Rikast i sällskapet är Mattias Djuses <strong>Knickers Sisu</strong> (e. Southwind Frank), som nådde sin största framgång med andraplatsen i långa E3 förra året, värd en miljon kronor.<br>Sjusiffrigt på priskontot har även Adrian Kolgjinis duo <strong>Countess Face</strong> (e. Muscle Hill) och <strong>Xia Lloyd</strong> (e. Raja Mirchi).</p>



<p><strong>I övrigt kan noteras: </strong></p>



<ul class="wp-block-list">
<li>Kelly Smartface (e. Captain Sparrow) är mest rutinerad med 26 starte innanför västen.</li>



<li>Daim Brodda (e. Readly Express) och Dial Square (e. Ready Cash) har bara gjort tio starter.</li>



<li>Countess Face (e. Muscle Hill) och Flamenco Girl (e. Maharajah) har vunnit flest lopp, åtta vardera.</li>



<li>Daim Brodda (e. Readly Express), Carmita Silvio (e. Maharajah) och Pure Diamond (e. Father Patrick) var finalister i Stochampionatet, där Daim Brodda lyckades bäst som trea, Carmita Silvio blev fyra och Pure Diamond sexa.</li>



<li>Countess Face (e. Muscle Hill) och Xia Lloyd (e. Raja Mirchi) var finalister i Drottningpokalen.</li>



<li>Dial Square (e. Ready Cash), Granger (e. Trixton) och Knickers Sisu (e. Southwind Frank) var finalister i Svenskt Trav-Oaks, där Dial Square var fyra och Granger femma.</li>



<li>Xia Lloyd (e. Raja Mirchi) slutade trea och Caia (e. Cantab Hall) oplacerad i Stosprintern.</li>



<li>Ingen finalist från Breeders Crown i höstas är med i Derbystoet.</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/2023/10/lutficapribi-617x333.jpg" alt="" class="wp-image-506003"/><figcaption class="wp-element-caption">Lutfi Kolgjini. Foto Lina Alm Racing Media</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 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>Lutfi Kolgjini har med hustrun Anna Svensson firat stora framgångar genom åren med parets Face-uppfödningar, men i Derbystoet står duon på noll vinster. Någon första gemensam seger blir det inte heller i år, men Lutfi Kolgjini har ändå dubbla chanser till en uppfödartriumf.<br>Han är nämligen deluppfödare i två finalister: <strong>Kelly Smartface</strong> (e. Captain Sparrow) tillsammans med Ecurie Smart och <strong>Countess Face</strong> (e. Muscle Hill) tillsammans med Johann Schembri. </p>



<p><strong>Uppfödare i Derbystoet:</strong></p>



<ul class="wp-block-list">
<li>Sonesta – Mats Bergman &#038; Gunilla Fehrm</li>



<li>Daim Brodda – Brodda Stuteri AB, Skurup</li>



<li>Kelly Smartface – Ecurie Smart &#038; Lutfi Kolgjini</li>



<li>Countess Face – Lutfi Kolgjini &#038; Johann Schembri</li>



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



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



<li>Pure Diamond – Marko Kreivi, Rönnäng</li>



<li>Caia – Riikka Avotie, Finland</li>



<li>Xia Lloyd –  Anders &#038; Viveca Fjelkner</li>



<li>Flamenco Girl – Menhammar Stuteri AB, Ekerö</li>



<li>Dial Square – Theorema Scand. AB &#038; FASAB Mark AB</li>



<li>Granger – Magnus Sjödin &#038; Peter Eriksson</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/2024/08/daimbroddetbm240820adamstromstalltz-617x424.jpg" alt="" class="wp-image-624195"/><figcaption class="wp-element-caption">Daim Brodda. Foto Adam Ström/Stalltz.se</figcaption></figure>



<p class="has-drop-cap">Readly Express och Ready Cash har gjort det förut. Alltså lämnat en avkomma som vunnit Derbystoet. Readly Express har haft tre finalister med dottern <strong>Honey Mearas</strong> – tränad av Daniel Redén – som vinnare, medan framlidne Ready Cash fått se 15 avkommor nå finalen tidigare. Petri Puro-tränade <strong>Cash Crowe</strong> ordnade segern 2017.<br>Stochampionatstrean <strong>Daim Brodda</strong> är Readly Express hopp, medan Ready Cash lutar sig mot <strong>Dial Square</strong>.</p>



<p>Elva hingstar står bakom dussinet stor som gör upp om segern i årets upplaga och Sveriges flerfaldige championhingst Maharajah är ensam om att vara pappa till två finalister. Tio gånger har han försökt tidigare med andraplatsen för <strong>Mulligan</strong> 2017 som främsta resultat. <br>Ska någon ur duon <strong>Carmita Silvio</strong> och <strong>Flamenco Girl</strong> bryta den segerlösa sviten?</p>



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



<p><em>Hingst (antal 2024) – Totalt – Finalister</em></p>



<ul class="wp-block-list">
<li><strong>Bold Eagle</strong> (1) – 3 – Dontlooseallmoney (0) 2020, Eagle Eye Sherry (0) 2021, Globalizer (0) 2021</li>



<li><strong>Cantab Hall</strong> (1) – 1 – Gina Mearas (0) 2020</li>



<li><strong>Father Patrick</strong> (1) – 1 Award Kronos (5) 2020</li>



<li><strong>Maharajah</strong> (2) – 10 – 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</li>



<li><strong>Muscle Hill</strong> (1) – 5 – Princess Face (0) 2016, Mellby Free (3) 2018, American Hill (0) 2020, Hall of Am (4) 2021, Hoboken Am (6) 2021</li>



<li><strong>Raja Mirchi</strong> (1) – 3 – Adi Galia (0) 2019, Losch Boko (5) 2022, Mirci A’lir (0) 2022</li>



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



<li><strong>Ready Cash</strong> (1) – 15 – Diamond River (2) 2015, Maya Gold (0) 2015, Caresse (4) 2016, Lady Cash (5) 2016, Darling Hornline (0) 2016, Cash Crowe (1) 2017, Caddie Lisieux (0) 2017, Fantasy River (0) 2017, Vamp Kronos (6) 2018, Dibaba (0) 2018, Milady Grace (2) 2020, Grande Diva Sisu (4) 2022, Great Skills (4) 2022, Isabelle Cash (0) 2022 , Jump In (0) 2022,</li>



<li><strong>Southwind Frank</strong> (1) – 1 – Senorita Tokio (2) 2022</li>



<li><strong>Trixton</strong> (1) – 3 – Alaska Kronos (3) 2020, Heloise Am (0) 2021, Loaded Maria (0) 2021</li>
</ul>



<p><strong>Captain Sparrow</strong> (1) har inte haft några startande avkommor tidigare. </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/10/countessface-617x333.jpg" alt="" class="wp-image-508585"/><figcaption class="wp-element-caption">Countess Face och Adrian Kolgjini. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



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



<p>Ägarna bakom fyra av finalisterna har varit med ”hela vägen” med sina ston. Som uppfödare och ägare. <strong>Countess Face, Carmita Silvio, Pure Diamond</strong> och <strong>Xia Lloyd</strong> ägs nämligen fortsatt av sina uppfödare.</p>



<p><strong>Hästägare i Derbystoet:</strong></p>



<ul class="wp-block-list">
<li>Sonesta – Stall Slugas</li>



<li>Daim Brodda – Stall Tonga Racing AB, Sätila</li>



<li>Kelly Smartface – SRF Stable</li>



<li>Countess Face – Lutfi Kolgjini &#038; Johann Schembri</li>



<li>Knickers Sisu – Kulturinvest I Sverige AB, Stockholm</li>



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



<li>Pure Diamond –  Göteborg Smart Repair Center AB</li>



<li>Caia – Petri Lahti-Luopa &#038; Dimitri Hedman, Finland</li>



<li>Xia Lloyd – Anders &#038; Viveca Fjelkner</li>



<li>Flamenco Girl – Metalimo i Malmö AB</li>



<li>Dial Square –  Stall Arsenal AB, Glimåkra</li>



<li>Granger – AB Torp &#038; Småhus i Västergötland, Benihana AB</li>
</ul>



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



<p class="has-drop-cap">Fyra av finalisterna har bytt ägare på auktion, en av dem två gånger dessutom. Dyrast i sällskapet är <strong>Daim Brodda</strong> (e. Readly Express) som såldes som ettåring på Åby Yearling &#038; Mixed Sale för 900.000 kronor till Stall Tonga Racing AB. Bakom köparens stallnamn döljer sig norske hästägaren Kjell Skatvedt. </p>



<ul class="wp-block-list">
<li>Daim Brodda – Åby Yearling Sale – 900.000 kr</li>



<li>Kelly Smartface – Kolgjini Yearling Sale – 500.000 kr</li>



<li>Sonesta – Elitauktionen – 300.000 kr</li>



<li>Flamenco Girl – Menhammar Online – 120.000 kr</li>



<li>Flamenco Girl* – Travera – 70.000 kr</li>
</ul>



<p>Knickers Sisu ropades åter för 150.000 kronor på Elitauktionen.<br>* Flamenco Girl såldes en andra gång som tvååring på Travera för 70.000 kronor.</p>



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



<p class="has-drop-cap">Av de tolv finalisterna var fyra ute och tävlade som tvååringar. <strong>Pure Diamond</strong>, som tränades av Jerry Riordan som tvååring, var flitigast och mest framgångsrik med tre andraplatser på fem starter.<br>Mattias Djuse-tränade <strong>Knickers Sisu</strong> var ensam om att vinna lopp, då hon tog hem en av två starter som tvååring.</p>



<p><strong>Derbystohästarnas resultat som tvååringar:</strong></p>



<ul class="wp-block-list">
<li>Pure Diamond (e. Father Patrick) – 5 st: 0-3-0, 84.000 kr</li>



<li>Caia (e. Cantab Hall) – 3 st: 0-1-0, 46.154 kr</li>



<li>Knickers Sisu (e. Southwind Frank) – 2 st: 1-0-0, 31.500 kr</li>



<li>Xia Lloyd (e. Raja Mirchi) – 2 st: 0-0-1, 12.000 kr</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/2024/08/xialloydakm240820adamstromstalltz-617x441.jpg" alt="" class="wp-image-624197"/><figcaption class="wp-element-caption">Xia lloyd. Foto Adam Ström/Stalltz.se</figcaption></figure>



<p class="has-drop-cap">Johanna Svensson, anställd hos Adrian Kolgjini, får ha blicken åt två håll i Derbystoet. Johanna är nämligen skötare till dubbla finalister. Hon ställer hoppen till <strong>Countess Face</strong> (e. Muscle Hill) och <strong>Xia Lloyd</strong> (e. Raja Mirchi).</p>



<p><strong>Hästskötare i Derbystoet:</strong></p>



<ul class="wp-block-list">
<li>Sonesta – Jakob Asplund</li>



<li>Daim Brodda – Maria Widnes</li>



<li>Kelly Smartface – Malin Boman-Friberg</li>



<li>Countess Face – Johanna Svensson</li>



<li>Knickers Sisu – Ebba Janius</li>



<li>Carmita Silvio – Wilma Karlsson</li>



<li>Pure Diamond – Malin Mogset</li>



<li>Caia – Matilda Bergström</li>



<li>Xia Lloyd – Johanna Svensson</li>



<li>Flamenco Girl – Ida Lindberg</li>



<li>Dial Square – Agnes Jakobsson</li>



<li>Granger – Laura Marttinen</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 nio senaste vinnarna av loppet har alla varit premiechansade och fått dubbla prischecken.</p>



<h2 class="wp-block-heading">Här är ”Det snackas om Derbyt”</h2>



<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="ac1Tcd1roy"><a href="https://sulkysport.se/duellen-med-stort-d/">Duellen med stort D</a></blockquote><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; visibility: hidden;" title="”Duellen med stort D” &ndash; Sulkysport" src="https://sulkysport.se/duellen-med-stort-d/embed/#?secret=ObGDGwpbXm#?secret=ac1Tcd1roy" data-secret="ac1Tcd1roy" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe>
</div></figure>


<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>
