
<p class="has-drop-cap">Fredrik Wallin vet hur man vinner Derbystoet – <strong>Global Dancer</strong> (e. Carat Williams) triumferade 2023 – och är en av tre av årets finaltränare som redan har ett mästarbälte från storloppet.</p>



<p>Wallins starka kort i årets upplaga är fyrfaldisga miljonärskan <strong>Bonsse Garde</strong> (e. Makethemark), som kvalade in till fyra storloppsfinaler som treåring och fick fullträffen genom segern i korta E3.<br>I år har siktet helt varit inställt på hösten, då Bonsse Garde inte var anmäld till Drottningpokalen, Stosprintern eller Stochampionatet.</p>



<p>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>Roger Walmann bockade av sin tredje tränarseger i loppet förra året när <strong>S.G.Empress</strong> (e. Readly Express) segrade – hans övriga är <strong>Handbag</strong> 1994 och <strong>Calamara Donna</strong> 2009 – och delar andraplatsen bland tränarna med Timo Nurmos och Peter Untersteiner på tre vinster.<br><strong>A View To A Kill</strong> (e. Trixton) är Walmanns hopp i år. Stoet inledde hos Per Nordström, såldes på auktion till Norge förra sommaren och tävlade för Lars Magne Sövik, innan hon när denne slutade som tränare kom till Roger Walmann i slutet av maj.</p>



<p>På två segrar finns Fredrik Persson, Petri Puro och Daniel Redén, där den sistnämnde har dubbla chanser att utöka segerskörden med duon <strong>Hankypanky Leonie</strong> (e. Readly Express) och <strong>Jiovanha Falkone</strong> (e. Don Fanucci Zet).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/04/danielreden-617x333.jpg" alt="" class="wp-image-705606"/><figcaption class="wp-element-caption">Daniel Redén. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Så här säger Daniel Redén om sina två finalister på sin hemsida <a href="http://reddis.se">reddis.se</a>:<br>– Hankypanky Leonie var jäkligt fin i försöket och vann utan att Rikard behövde dra norsken. Hon har en härlig inställning och utvecklats fint och barfotakörningen har varit perfekt för henne. I måndags provade jag att rycka tussarna på henne för första gången och fick precis ett sånt svar som jag önskar så hon kommer utrustas så den här gången. Spåret är bra för henne då hon är lite långstegad och det blir barfota igen.</p>



<p>– Jiovanha Falkone överraskade mig med att spurta in till den här finalen och hon har lyft sig och även musklat på sig och det är roligt att se. Örjan sa även att han kände det redan näst senast att något har hänt med henne och allt ser bra ut i jobben så hon kommer prestera på samma nivå som senast. Läget är svårt och hon får likt senast smyga med och spurta till slut. Barfota runt om och bike.</p>



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



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



<ol class="wp-block-list">
<li><strong>Nyharajah</strong> (e. Maharajah) – Thomas Dalborg (Henrik Nyberg)</li>



<li><strong>Meditate</strong> (e. Greenshoe) – Mats E Djuse (Stefan P Pettersson)</li>



<li><strong>Sassy But Classy</strong> (e. Maharajah) – Magnus A Djuse (Tomas Malmqvist)</li>



<li><strong>Hankypanky Leonie</strong> (e. Readly Express) – Rikard N Skoglund (Daniel Redén)</li>



<li><strong>Bonsse Garde</strong> (e. Makethemark) – Carl Johan Jepson (Fredrik Wallin)</li>



<li><strong>Peggy Boko</strong> (e. Robert Bi) – Robin Bakker (Paul Hagoort)</li>



<li><strong>Global Good News</strong> (e. S.J.’s Caviar) – Andreas Lövdal</li>



<li><strong>Timotejs Online</strong> (e. Face Time Bourbon) – Björn Goop</li>



<li><strong>Princessofthedawn</strong> (e. Maharajah) – André Eklundh</li>



<li><strong>Slipstream Zon</strong> (e. Googoo Gaagaa) – Tom Erik Solberg (Anna Forssell)</li>



<li><strong>Jiovanha Falkone</strong> (e. Don Fanucci Zet) – Öjan Kihlström (Daniel Redén)</li>



<li><strong>A View To A Kill</strong> (e. Trixton) – Claes Sjöström (Roger Walmann)</li>
</ol>



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



<p class="has-drop-cap">För premiechansad häst adderas 50 procent extra prispengar och samtliga tolv finalisters ägare valde premiechansen istället för att låta sin häst gå premielopp som tvååring.</p>



<p><strong>Så här blir prisskalan i Derbystoet 2026:</strong><br>1.500.000-750.000-375.000-180.000-120.000-75.000 kr</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/10/sassybutclassyeagk-617x333.jpg" alt="" class="wp-image-649845"/><figcaption class="wp-element-caption">Sassy But Classy och Erik Adielsson vid segern i Svampen 2024. Foto Gunilla König/Stalltz.se</figcaption></figure>



<p class="has-drop-cap">B<strong>onsse Garde</strong> (e. Makethemark) sticker ut när det gäller tyngsta meriterna, men det finns ytterligare en storloppsvinnare i finalfältet i Derbystoet.</p>



<p>Fuxan <strong>Sassy But Classy</strong> (e. Maharajah) inledde tävlingskarriären hos Tomas Malmqvist och vann Svampen i Örebro som tvååring med nuvarande domarbasen Erik Adielsson vid tömmarna. När Malmqvist blev avstängd flyttades stoet förra sommaren till Daniel Wäjersten och tog fjärdeplatsen i korta E3, men sedan slutet av juni i år är hon tillbaka hon numera Halmstadtränaren Malmqvist.</p>



<p>Hela tio av de tolv finalisterna har varit med i någon eller några av kullens största finaler hittills i karriären. De som debuterar i de största sällskapen är <strong>Hankypanky Leonie</strong> (e. Readly Express) och <strong>A View To A Kill</strong> (e. Trixton).</p>



<h2 class="wp-block-heading">Derbystofinalisternas resultat i årgångslopp</h2>



<p><strong>Tvååringslopp:</strong></p>



<ul class="wp-block-list">
<li>Svampen: <strong>Sassy But Classy</strong> (etta)</li>



<li>Breeders Course: Sassy But Classy (sexa)</li>
</ul>



<p><strong>Treåringslopp: </strong></p>



<ul class="wp-block-list">
<li>Långa E3: Bonsse Garde (fyra), Global Good News (oplacerad)</li>



<li>Korta E3: <strong>Bonsse Garde</strong> (etta), Sassy But Classy (fyra)</li>



<li>Oaks: Bonsee Garde (trea), Slipstream Zon (femma), Timotejs Online (oplacerad)</li>



<li>Breeders Crown: Bonsse Garde (tvåa), Global Good News (trea)</li>
</ul>



<p><strong>Fyraåringslopp: </strong></p>



<ul class="wp-block-list">
<li>Drottningpokalen: Slipstream Zon (femma), Nyharajah (sexa), Global Good News (oplacerad), Princessofthedawn (oplacerad)</li>



<li>Stosprintern: Princessofthedawn (trea)</li>



<li>Stochampionatet: Peggy Boko (trea), Meditate (femma), Jiovanha Falkone (sexa)</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/2026/07/jiovanhafalkone-1-617x333.jpg" alt="" class="wp-image-875057"/><figcaption class="wp-element-caption">Jiovanha Falkone och Örjan Kihlström. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Örjan Kihlström är kuskdominanten i Derbystoet. Fem gånger har han suttit bakom vinnaren, varav två från Daniel Redéns stall. Åt denne kör Kihlström även i årets upplaga när han rattar <strong>Jiovanha Falkone</strong> (e. Don Fanucci Zet).</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.</p>



<p>Vid sidan om Kihlström har Rikard N Skoglund och Carl Johan Jepson vunnit Derbystoet. Skoglund har dessutom gjort det två gånger. 2019 var segervapnet Mattias Djuse-tränade <strong>Racing Brodda</strong> (e. Prodigious) och ifjol satt han upp bakom Roger Walmanns vinnare <strong>S.G.Empress</strong> (e. Readly Exprtess).<br>Nu har han chansen igen med försöksvinnaren <strong>Hankypanky Leonie</strong> (e. Readly Express) från Daniel Redéns stall.</p>



<p>Carl Johan Jepson tog hjälp av Fredrik Wallin när han bärgade sin seger i Derbystoet, för tre år sedan med <strong>Global Dancer</strong> (e. Carat Williams). Samme Wallin tränas Jepsons styrning i år, finalfältets i särklass mest meriterade häst <strong>Bonsse Garde</strong> (e. Makethemark).</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/2026/08/skarmavbild20260825kl.19.02.27-617x373.jpg" alt="" class="wp-image-890763"/><figcaption class="wp-element-caption">Björn Goop vann bakom Henrik Nybergs Nyharajah. Foto: Stefan Olsson/Cavok</figcaption></figure>



<p class="has-drop-cap">Rainer Ström gjorde det premiäråret 1991 genom <strong>Charm Patricia</strong> (e. Keystone Patriot), Roine Anderssson var mannen bakom <strong>Blue Bahia</strong> (e. Meadow Gallant) 1998 och Lennart Mossberg tränade <strong>Eli Sea</strong> (e. Running Sea) till vinst i 2002 år upplaga. Den gemensamma nämnaren? Trion var alla amatörtränare.</p>



<p>Henrik Nyberg bär B-tränarnas fana i årets upplaga av Derbystoet, där han tagit egna uppfödningen <strong>Nyharajah</strong> (e. Maharajah) till en ny storloppsfinal. Nyharajah var sexa i Drottning Silvias Pokal i maj.</p>



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



<p class="has-drop-cap">Fyra av Derbystohästarna ropades in av sina ägare på ettråingsauktioner och det handlade inte om några riktiga dyringar i sammanhanget. Däremot har inköpssumman omvandlats fint i samtliga fall.</p>



<p><strong>Bonsse Garde</strong> (e. Makethemark) var dyrast i kvartetten när hon såldes för 190.000 kronor på Next Generation Sale. Idag står hon med över 4,1 miljoner kronor intjänat.<br><strong>Timotejs Online</strong> (e. Face Time Bourbon) kostade 10.000 kronor mindre och har klivit över 900.000 kronor i karriären. <strong>Jiovanha Falkone</strong> (e. Don Fanucci Zet) klubbades för 100.000 kronor och närmar sig sin första halvmiljon, medan <strong>Slipstream Zon</strong> (e. Googoo Gaagaa) var ett riktigt fynd för 60.000 kronor. Inför Derbystoet finns 875.750 kronor på priskontot.</p>



<p><strong>Häst – Auktion – Pris</strong></p>



<ul class="wp-block-list">
<li><strong>Bonsse Garde</strong> – Next Generation Sale – 190.000 kr</li>



<li><strong>Timotejs Online</strong> – Criterium Sale – 180.000 kr</li>



<li><strong>Jiovanha Falkone</strong> – Criterium Sale – 100.000 kr</li>



<li><strong>A View to A Kill*</strong> – Travera – 90.000 kr</li>



<li><strong>Slipstream Zon</strong> – Åby Yearling Sale – 60.000 kr</li>
</ul>



<p><strong>Fotnot: Sassy But Classy</strong> var ett återrop för 80.000 euro på Selected Sales i Danmark. <strong>Nyharajah</strong> togs tillbaka för 200.000 kronor på Elitauktionen. <strong>Peggy Boko</strong> var struken från Elitauktionen. <strong>A View to A Kill</strong> köptes på Travera ifjol som treåring. </p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/08/skarmavbild20260825kl.18.35.03-617x408.jpg" alt="" class="wp-image-890751"/><figcaption class="wp-element-caption">Hankypanky Leonie. Foto: Stefan Olsson/Cavok</figcaption></figure>



<p class="has-drop-cap">Readly Express är den nye avelskungen i Derbystoet. På fem kullar på tävlingsbanan har det blivit tre segrar genom <strong>Honey Mearas, Daim Brodda</strong> och ifjol <strong>S.G.Empress</strong>. Försöksvinnaren <strong>Hankypanky Leonie</strong> är dottern i årets final.</p>



<p>Tio avelshingstar står bakom de tolv finalisterna och Sveriges flerfaldige champion Maharajah är dominant med tre finalister. Maharajah väntar fortfarande på sin första seger som pappa i loppet. Han har haft 14 startande döttrar i final tidigare och nu ställer han hoppet till trion <strong>Nyharajah, Sassy But Classy</strong> och <strong>Princessofthedawn</strong>.</p>



<p>Fyra avelshingstar har sin första finalist i loppet.</p>



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



<p><em>Hingst (antal 2026) – Totalt – Tidigare finalister</em></p>



<ul class="wp-block-list">
<li><strong>Face Time Bourbon</strong> (1) – 1 – Screen Time Limit (4) 2025</li>



<li><strong>Greenshoe</strong> (1) – 1 – Love Bites (0) 2025</li>



<li><strong>Maharajah</strong> (3) – 14 – 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, Giraffa (2) 2025, Elegance Silvio (3) 2025</li>



<li><strong>Readly Express</strong> (1) – 5 – <strong>Honey Mearas</strong> (1) 2021, Tilda Express (0) 2021, Aurelia Express (0) 2023, <strong>Daim Brodda</strong> (1) 2024, <strong>S.G. Empress</strong> (1) 2025</li>



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



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



<p><strong>Fotnot: Don Fanucci Zet</strong> (1), <strong>Googoo Gaagaa</strong> (1), <strong>Makethemark</strong> (1) och <strong>Robert Bi</strong> (1) har sin första startande avkomma. </p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/04/ganymedestalltz.sesm-617x382.jpg" alt="" class="wp-image-834498"/><figcaption class="wp-element-caption">Jean-Pierre Dubois och Ganymede vinner Oslo Grand Prix. Foto: stalltz.se</figcaption></figure>



<p class="has-drop-cap">USA mot Frankrike är matchen på morfarssidan i Derbystoet. Sex amerikanska morfäder med en ättling vardera ställs mot fyra franska hingstar med fem barnbarn till start. Den tolfte finalistens morfar är italienskfödde <strong>Daguet Rapide</strong> – med amerikansk pappa i Pine Chip och fransk mamma i Hangone.</p>



<p>Den ende med seger som morfar i Derbystoet hittills är <strong>Muscle Hill</strong>, vars barnbarn <strong>Lara Boko</strong> segrade för fyra år sedan.</p>



<p>Franske <strong>Ganymede</strong> har aldrig tidigare varit morfar till en häst i Derbystoet. I årets upplaga har han två.</p>



<p><strong>Morfäder i Derbystoet</strong>:<br><em>Morfar (antal 2026) – Totalt –  Tidigare finalister</em></p>



<ul class="wp-block-list">
<li><strong>Cantab Hall</strong> (1) – 5 – Europhile Am (2) 2018, Aleppo Pine (0) 2019, Mellby Harissa (0) 2020, Miss Imperatrice (0) 2022, Daim Brodda (1) 2024</li>



<li><strong>Daguet Rapide</strong> (1) – 2 – Grande Diva Sisu (4) 2020, Loaded Maria (0) 2021</li>



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



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



<li><strong>Pine Chip</strong> (1) – 3 – Oklahoma Broline (0) 2015, Princess Face (0) 2016, Catch My Love (0) 2018</li>



<li><strong>S.J.’s Caviar</strong> (1) – 2 – Backfire (4) 2014, Love This Bar (str.) 2025</li>



<li><strong>Trixton</strong> (1) – 1 – Ulaya (0) 2025</li>



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



<p><strong>Fotnot: Ganymede</strong> (2), <strong>Prodigious</strong> (1) och <strong>Sam Bourbon</strong> (1) har sina första startande barnbarn i Derbystoet.</p>



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



<p class="has-drop-cap">Andreas Lövdal är på väg mot nya äventyr sedan han köpt Daniel Wäjerstens gård utanför Sundsvall och flyttlasset lär går runt årsskiftet.</p>



<p><strong>Global Good News</strong> (e. S.J.’s Caviar) har bara vunnit ett lopp på 23 försök i karriären, men har kvalificerat sig för sin fjärde storloppsfinal. Höjdpunkten hittills är tredjeplatsen i Breeders Crown förra hösten.</p>



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



<p class="has-drop-cap">Fjolårets Oaksvinnare och världsrekordtravare <strong>Moder Teresa Sisu</strong> (e. Walner) missade att kvala in till Derbystoet, men tre av finalisterna från de treåriga stonas största lopp finns med i finalen.</p>



<p>Förutom Oakstrean Bonsse Garde handlar det om duon <strong>Timotejs Online</strong> (e. Face Time Bourbon) och <strong>Slipstream Zon</strong> (e. Googoo Gaagaa).</p>



<p>Björn Goop tränar den förstnämnda och han väntar faktiskt både på första segern som kusk och tränare i Derbystoet. Pappa Olle vann loppet en gång, med<strong> Mack Action Ås</strong> (e. Mack Lobell) 1998.</p>



<p>Slipstream Zon får – precis som i försöket – norske catchndrivern Tom Erik Solberg i vagnen. En norsk kusk har vunnit Derbystoet tidigare. För två år sedan styrde landets segerrikaste kusk genom tiderna, Eirik Höitomt, <strong>Daim Brodda</strong> (e. Readly Express) till vinst.</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/07/falsigboportr-617x333.jpg" alt="" class="wp-image-327209"/><figcaption class="wp-element-caption">Bo Falsig har uppfödning i Derbystoet på söndag. Foto Mia Törnberg/Sulkysport</figcaption></figure>



<p class="has-drop-cap">För fyra år sedan slutade Bo Falsig efter många år som proffstränare och idag arbetar han med hovslagarutbildning och hästskor – plus att han dyker upp titt som tätt som värmningsexpert i ATG Live.</p>



<p>Faldig var även uppfödare i liten skala och ett av resultaten från den gärningen är miljonärskan <strong>Princessofthedawn</strong> (e. Maharajah), som tidigare i år kvalat in till Drottningpokalen och tagit tredjeplatsen i Stosprintern i André Eklundhs regi.<br>Åtta dagar efter att Falsig slutat som travtränare var alla hans ägda och delägda hästar sålda, så Princessofthedawn följde med i den svängen.<br>– Jag hade kanske åtta eller nio delägda hästar vid den tidpunkten och att stå med dessa kostnader när man inte håller på själv, det håller inte, säger han.</p>



<p><a href="https://sulkysport.se/derbystoet-falsig-hoppas-pa-permis/" target="_blank" rel="noreferrer noopener">––> Läs hela intervjun med Bo Falsig här!</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/2026/08/peggyboko-617x441.jpg" alt="" class="wp-image-890810"/><figcaption class="wp-element-caption">Peggy Boko och Robin Bakker höll undan från spets. Foto: Stefan OLsson/Cavok</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 35 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>John Bootsmans uppfödning Boko Stables Holland BV, Nederländerna, är ensam bland årets finalister om att ha tagit fram en vinnare tidigare. <br><strong>Peggy Boko</strong> (e. Robert Bi) är en dotter till en riktig juvel i Bootmans uppfödning. Modern <strong>Sue Boko</strong> (e. Yankee Glide), 1.12,3ak/834.216 kr, är amerikanska och hittades i USA av Martti Ala-Seppälä och Timo Nurmos. På nedlagda Kentucky Standardbred-auktionen i Lexington ropades stoet in för 30.000 dollar. John Bootsman köpte dottern till Yankee Glide och Chipping Away kort senare.</p>



<p>I avelsboxen har Sue Boko utsetts till Elitsto efter starka resultat. Det stora namnet är Kriterievinnaren <strong>Inti Boko</strong> (e. Chocolatier), 1.09,9ak/6.196.154 kr. <strong>Amaru Boko</strong> (e. Coktail Jet), 1.10,3ak*/4.370.093 kr, vann långa E3 och <strong>Grant Boko</strong> (e. Ready Cash), 1.10,9ak/2.735.649 kr, tog hem Breeders Crown.</p>



<p>Peggy Boko, 1.12,1am*/1.377.777 kr, tränas av Paul Hagoort och raketspurtade till tredjeplatsen i Stochampionatet.</p>



<p><strong>Här är uppfödarna bakom finalisterna i Derbystoet:</strong></p>



<ol class="wp-block-list">
<li>Nyharajah – Cecilia &#038; Henrik Nyberg</li>



<li>Meditate – Stall Courant AB, Heby</li>



<li>Sassy But Classy – Panamera Racing v/Jens Glud Hansen</li>



<li>Hankypanky Leonie – Ulf &#038; Anna-Maria Lundqvist</li>



<li>Bonsee Garde – Garde Hästar AB, Sala</li>



<li>Peggy Boko – Boko Stables Holland BV, Nederländerna</li>



<li>Global Good News – Global Farm AB, Nacka</li>



<li>Timotejs Online – Mona Elsert &#038; Hans Östberg</li>



<li>Princessofthedawn – Travtränare Bo Falsig AB, med flera</li>



<li>Slipstream Zon – Torbjörn &#038; Madelen Ohlzon</li>



<li>Jiovanha Falkone – Ulf Lindström, Luleå</li>



<li>A View To A Kill – Flaata Stable AS, Norge</li>
</ol>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/08/dsc27101-e1787676495520-617x388.jpg" alt="" class="wp-image-890755"/><figcaption class="wp-element-caption">Meditate och Carl Johan Jepson vann det första uttagningsloppet till Derbystoet.<br>Foto: Stefan Olsson/Cavok</figcaption></figure>



<p class="has-drop-cap">Två av landets allra framgångsrikaste hästägare finns med i Derbytstoet. Stall Courant triumferade i Svenskt Travderby för tre år sedan genom superstoet <strong>Joviality</strong> (e. Chapter Seven), men någon seger i Derbystoet har dock inte hårdsatsande Anders Ström. Nu kommer nästa chans genom Stefan P Pettersson-tränade <strong>Meditate</strong> (e. Greenshoe), som varit finalist i både Drottningpokalen och Stochampionatet tidigare i år.</p>



<p>Stall Courants och Stefan P Petterssons största seger tillsammans är annars <strong>Kitty Hawks</strong> (e. Fourth Domension) triumf i Stosprintern. Då körde Mats E Djuse till vinst – och samme Djuse sitter i jänkarvagnen bakom Meditate.</p>



<p>Stall Zet är ensam om två segrar som hästägare i Derbystoet efter <strong>Diana Zets</strong> och <strong>Honey Mearas</strong> triumfer och <strong>Jiovanha Falkone</strong> är hästen som kan fylla på med ytterligare en ägartriumf.</p>



<p><strong>Här är hästägarna bakom finalisterna i Derbystoet:</strong></p>



<ol class="wp-block-list">
<li>Nyharajah – Nygårdens Stuteri &#038; Veterinär AB, Varnhem</li>



<li>Meditate – Stall Courant AB, Heby</li>



<li>Sassy But Classy – Panamera Racing v/Jens Glud Hansen</li>



<li>Hankypanky Leonie – Ulf &#038; Anna-Maria Lundqvist</li>



<li>Bonsee Garde – Terästallit Oy &#038; Garde Hästar AB</li>



<li>Peggy Boko – Panamera Racing v/J Glud Hansen, med flera</li>



<li>Global Good News – Ofcourse KB, Kovland</li>



<li>Timotejs Online – Karin Walter-Mommert, Tyskland</li>



<li>Princessofthedawn – Pure Islet AB &#038; Bullbiet HB</li>



<li>Slipstream Zon – Petras HB, Göteborg</li>



<li>Jiovanha Falkone – Stall Zet (Daniel Redén)</li>



<li>A View To A Kill – Jahre Stable AB, Karlstad</li>
</ol>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/07/fredrikwallin6107-617x333.jpg" alt="" class="wp-image-870919"/><figcaption class="wp-element-caption">Fredrik Wallin. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Fredrik Wallin har över 90 hästar i träning och många anställda, men när det gäller fyrfaldiga miljonärskan <strong>Bonsse Garde</strong> (e. Makethemark) står han själv som skötare. Med stor framgång har det visat sig.</p>



<p>Vassa meriter som skötare har också fransyskan Constanza Flores, som skötte självaste Ready Cash under flera år hos Philippe Allaire. Nu har hon hand om André Eklundhs <strong>Princessofthedawn</strong> (e. Maharajah).</p>



<p><strong>Hästskötare – Finalist</strong></p>



<ul class="wp-block-list">
<li>Pelle Hurtsén – Nyharajah</li>



<li>Martina Lundin – Meditate</li>



<li>Camilla Ahlqvist – Sassy But Classy</li>



<li>Joline Kjellstrand – Hankypanky Leonie</li>



<li>Fredrik Wallin – Bonsee Garde</li>



<li>Kim Hagoort – Peggy Boko</li>



<li>Lucas Carnemar – Global Good News</li>



<li>Iida Lind – Timotejs Online</li>



<li>Constanza Flores – Princessofthedawn</li>



<li>Anna Forssell – Slipstream Zon</li>



<li>Carolina Persson – Jiovanha Falkone</li>



<li>Helene Walmann-Lindstedt  – A View To A Kill</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><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) – 1.11,9a</p>
<p>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>



<p></p>



<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="xNPHUvFzPS"><a href="https://sulkysport.se/vem-ar-esset-i-leken/">Vem är esset i leken?</a></blockquote><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; visibility: hidden;" title="”Vem är esset i leken?” &ndash; Sulkysport" src="https://sulkysport.se/vem-ar-esset-i-leken/embed/#?secret=Kc28GoQ9L2#?secret=xNPHUvFzPS" data-secret="xNPHUvFzPS" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe>
</div></figure>
