
<p class="has-drop-cap">Fredrik Wallin vet hur man vinner Stochampionatet som tränare. Carl Johan Jepson likaså som kusk. Tillsammans låg de bakom 2019 års vinnare <strong>Activated</strong> (e. Jocose). Nu mönstrar duon försöksvinnaren och kullens vinstrikaste sto <strong>Pure Athena</strong> (e. Bar Hopping), som efter två månaders uppehåll efter triumfen i Drottning Silvias Pokal tog hem sitt försök på bra sätt – som snabbaste försöksvinnare.<br>– Det var en otroligt skön känsla att få se henne göra så där och gå undan på lätta ben. Målet har varit att vi inte ska tävla så mycket då vi vet att fyraåringssäsongen för stona är väldigt tuff, och har vi kommit till den här klassen så har vi bara de här stora loppen som gäller. Hon var bra förberedd till kvalet men kommer absolut att lyfta sig fram till finalen, säger Fredrik Wallin till Kanal75.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/05/pureathenakrans260509adamstromstalltz-e1783624224389-617x417.jpg" alt="" class="wp-image-848179"/><figcaption class="wp-element-caption">Pure Athena efter segern i Drottning Silvias Pokal. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p>Pure Athena hade en urstark tvååringssäsong som två raka vinster i Norrlands Elitserie och Breeders Crown och inbringade 1.314.250 kronor. Dessutom vann hon försök i Breeders Course, slutade trea i Svensk Uppfödningslöpning och travade sju tiondelar under gällande världsrekord för tvååriga ston som tvåa över medeldistans.<br>Ifjol blev det bara sex starter (3-0-3) och försommaren gav tredjeplatser i både Breeders Course-finalen och långa E3, men sedan missade hon resten av sommaren och hösten, innan det blev ett par starter sent på året.</p>



<p>I år har hon kommit tillbaka med dunder och brak och plockade hem försök och final i Drottning Silvias Pokal.</p>



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



<p>2.640 meter autostart, Axevalla söndag<br><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li><strong>Pamela Boko</strong> (e. Don Fanucci Zet) – Magnus A Djuse (Timo Nurmos)</li>



<li><strong>Dats Bella</strong> (e. Power) – Claes Sjöström (Eric Martinsson)</li>



<li><strong>Love To The Limit</strong> (e. Bold Eagle) – Björn Goop</li>



<li><strong>Milady Josselyn</strong> (e. Ready Cash) – Dante Kolgjini (Lutfi Kolgjini)</li>



<li><strong>Pure Athena</strong> (e. Bar Hopping) – Carl Johan Jepson (Fredrik Wallin)</li>



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



<li><strong>Selmina Venit</strong> (e. Donato Hanover) – André Eklundh (Eric Martinsson)</li>



<li><strong>True Identity</strong> (e. Muscle Mass) – Markus B Svedberg</li>



<li><strong>Jiovanha Falkone</strong> (e. Don Fanucci Zet) – Johan Untersteiner (Daniel Redén)</li>



<li><strong>Candie Lock</strong> (e. Flocki d’Aurcy) – Thomas Dalborg</li>



<li><strong>Pure Stella</strong> (e. Readly Express) – Rikard N Skoglund (Katja Melkko)</li>



<li><strong>Meditate</strong> (e. Greenshoe) – Mats E Djuse (Stefan P Pettersson)</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/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">Av tränarna bakom årets finalister har fem redan fått uppleva känslan att vinna Stochampionatet som tränare en eller flera gånger. Daniel Redén har dessutom gjort det fyra gånger på de sex senaste åren.</p>



<p>Timo Nurmos (<strong>Vala Boko</strong>), Björn Goop (<strong>Mellby Free</strong>), Lutfi Kolgjini (<strong>Simb Capi</strong>) och nämnde Fredrik Wallin (<strong>Activated</strong>) har gjort det en gång vardera.</p>



<p>Titelförsvarare Redén är själv i Finland för att köra Double Deceiver i S:t Michel Ajo och får följa försöksvinnaren <strong>Jiovanha Falkone</strong> (e. Don Fanucci Zet). Precis så var det även förra året när Redén vann det finska storloppet samtidigt som <strong>La Yuca</strong> (e. Face Time Bourbon) plockade hem Stochampionatet.<br>– Det var lite överraskande att Jiovanha Falkone vann sitt försök för förberedelserna hade inte varit de bästa med sjukdom och att hon inte startat på länge. Hon gjorde det i alla fall väldigt bra för hon gick en bra bit i andra spår utan rygg och visade bra moral över upploppet. Hon kommer vara klart förbättrad till detta. Läget blev okey för hon ska vara på innerspår och få ett snällt lopp för att få med sig så mycket som möjligt, säger Daniel Redén på sin hemsida <a href="http://reddis.se">reddis.se</a>.</p>



<p>Där berättar att stoet ska tävla med lättare boots fram och första gången med rycktussar, vilket hon svarade bra på i veckan enligt tränaren.</p>



<p>Två tränare har dominerat stort i loppets historia. Stig H Johansson toppar med sex triumfer (han körde alla vinnare själv), medan Olle Goop låg bakom fem vinnare, där han tog hjälp av sonen Björn med <strong>Carolinas Mystic</strong> och Jim Frick bakom <strong>Tamila Glory</strong>.</p>



<p><strong>Tränare med två eller fler vinnare i Stochampionatet:</strong></p>



<ul class="wp-block-list">
<li>Stig H Johansson – 6 – Holly Rodney 1977, Gina Roy 1988, Queen L. 1990, Bowls Lady 1991, Fiona San 1995, Je T’aime Dream 2003</li>



<li>Olle Goop – 5 – Sweet Bear 1983, Intact 1986, Tamila Glory 1989, Carolinas Mystic 1997, Princess V. 1999</li>



<li>Daniel Redén – 4 – Diana Zet 2020, Honey Mearas 2021, Kinglet Bird 2024, La Yuca 2025</li>



<li>Roger Walmann – 3 – Giant Diablo 2004, Calamara Donna 2009, Tamla Celeber 2011</li>



<li>Tommy Hanné – 2 – Royaling, Volita du Ling</li>



<li>Stefan Hultman – 2 – Pine Dust 2002, Lie Detector 2008</li>



<li>Sören Nordin – 2 – Gaby Gulwark 1973, Fonians 1975</li>



<li>Bo Näslund – 2 – Kristina Palema 1985, Emelie Palema 1987</li>



<li>Fredrik Persson – 2 – Viola Silas 2010, Ultra Bright 2017</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/datsbellaem-617x333.jpg" alt="" class="wp-image-874824"/><figcaption class="wp-element-caption">Dats Bella och Eric Martinsson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Stochampionatet ingått i premiechansen med chans till större prischeckar sedan 2017 och det har många hästägare dragit nytta av. Den enda bland topp sex 2017-2025 som inte varit premiechansad är 2017 års trea <strong>Schatzi Fayline</strong> (e. Maharajah).</p>



<p>För de tre hemmahästarna <strong>Candie Lock</strong> (e. Flocki d’Aurcy), <strong>Dats Bella</strong> (e. Power) och <strong>Selmina Venit</strong> (e. Donato Hanover) ger förutom äran en seger i Stochampionatet 1,2 miljoner kronor. Övriga nio finalister kan kamma hem 1,8 miljoner.<br>Ägarna bakom nämnda trio valde att låta sin häst gå premielopp som tvååringar – 20.000 kronor – och avstå premiechansen med 50 procent extra prispengar i ett antal utvalda storlopp, däribland Stochampionatet.</p>



<p><strong>Ordinarie prisskala:</strong><br>1.200.000-600.000-300.000-144.000-96.000-60.000 kronor</p>



<p><strong>Prisskala för premiechansade hästar:</strong><br>1.800.000-900.000-450.000-216.000-144.000-90.000 kronor</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2019/07/activatedmal-617x365.jpg" alt="" class="wp-image-48499"/><figcaption class="wp-element-caption">Activated kom längst ut i banan vid skrällseger i Stochampionatet 2019. Foto Simon Hagen/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Under drygt 40 år har samma sto vunnit både Drottning Silvias Pokal och Stochampionatet 14 gånger. Och det är ingen dålig samling blågula ston som tar plats på listan över dubbelvinnare.</p>



<p>I år kan Fredrik Wallin-tränade <strong>Pure Athena</strong> (e. Bar Hopping) göra dem sällskap – och Wallin vet hur man gör. Hans första storstjärna <strong>Activity</strong> (e. Jocose) lyckades med just den bedriften 2019.</p>



<p><strong>Hästarna som vunnit Drottningpokalen och Stochampionatet:</strong><br><em>År, häst (far) – Tränare</em></p>



<ul class="wp-block-list">
<li>1985 Kristina Palema (e. Quick Pay) – Bo Näslund</li>



<li>1986 Intact (e. Netted) – Olle Goop</li>



<li>1988 Gina Roy (e. Speedy Min) – Stig H Johansson</li>



<li>1991 Bowls Lady (e. Super Bowl) – Stig H Johansson</li>



<li>1993 Ina Scot (e. Allen Hanover) – Kjell P Dahlström</li>



<li>1998 Simb Capi (e. Probe) – Lennart Wikström/Lutfi Kolgjini</li>



<li>2000 Sweet As Candy (e. Smasher) – Lars-Eric Magnusson</li>



<li>2004 Giant Diablo (e. Supergill) – Roger Walmann</li>



<li>2005 Fama Currit (e. Viking Kronos) – Petri Puro</li>



<li>2008 Lie Detector (e. Varenne) – Stefan Hultman</li>



<li>2010 Viola Silas (e. Lindy Lane) – Fredrik Persson</li>



<li>2011 Tamla Celeber (e. Cantab Hall) – Roger Walmann</li>



<li>2019 Activated (e. Jocose) – Fredrik Wallin</li>



<li>2020 Diana Zet (e. Hard Livin) – 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/2021/07/carolinasmysticpris-617x333.jpg" alt="" class="wp-image-189982"/><figcaption class="wp-element-caption">Björn och Olle Goop flankerar Carolinas Mystic efter Stochampionatet 1997. Foto Stefan Melander/Stalltz.se</figcaption></figure>



<p class="has-drop-cap">Björn Goop tog sin första storseger som kusk när han 1997 vann med den av pappa Olle tränade <strong>Carolinas Mystic</strong> (e. Karate Chop) som 46-oddsare. Som tränare kom första segern 2018 med <strong>Mellby Free</strong> (e. Muscle Hill).</p>



<p>I år har han åter ett egentränat sto i loppet i <strong>Love To The Limit</strong> (e. Bold Eagle), som har sin främsta merit i andraplatsen i korta E3-finalen ifjol.<br>Uppfödaren Mike Lenders är verksam som travtränare i Normandie med ett tiotal hästar på träningslistan och ha tagit 329 segrar som tränare i Frankrike.</p>



<p>Love To The Limits USA-födda moder <strong>Scullys Girl</strong> (e. Muscle Hill) är verkligen en plusvariant i aveln. Hon har tidigare lämnat danskfödde <strong>Hurricane D.K.</strong> (e. Father Patrick), 1.11,3ak/1.277.972 dkr, som vann Breeders Course-final på Solvalla Elitloppsdagen 2022, och svenskfödde Vincennesvinnaren <strong>Force of Nature</strong> (e. Brillantissime), 1.11,8l*/1.173.812 kr.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/07/lovetothelimit-1-617x333.jpg" alt="" class="wp-image-875060"/><figcaption class="wp-element-caption">Love To The Limit och Björn Goop. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p><strong>Försöksvinnarna i Stochampionatet:</strong><br><em>Häst – Tränare – Segertid</em></p>



<ul class="wp-block-list">
<li>Pure Athena – Fredrik Wallin – 1.13,1a</li>



<li>Milady Josselyn &#8211; Lutfi Kilgjini – 1.13,4a</li>



<li>Dats bella – Eric Martinsson – 1.14,1a</li>



<li>Pamela Boko – Timo Nurmos – 1.14,2a</li>



<li>Jiovanha Falkone – Daniel Redén – 1.14,3a</li>



<li>Love To The Limit – Björn Goop – 1.14,9a</li>
</ul>



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



<p class="has-drop-cap">Örjan Kihlström är kungen bland kuskarna i Stochampionatet. När han vann med Daniel Redéns <strong>La Yuca</strong> (e. Face Time Bourbon) förra året var det hans tionde seger i Axevallas storlopp. Fler än någon annan – men i år lämnar han fältet öppet för de andra kuskarna.</p>



<p>Örjan kör nämligen <strong>Don Fanucci Zet</strong> (e. Hard Livin) i grupp I-loppet S:t Michel Ajo i Finland idag istället för hans försöksvinnare <strong>Jiovanha Falkone</strong> (e. Don Fanucci Zet), som får Johan Untersteiner i jänkarvagnen.</p>



<p><strong>Här är Örjan Kihlströms vinnare:</strong><br><strong>Royaling</strong> (e. Royal Prestige) 1992, <strong>Pine Dust</strong> (e. Pine Chip) 2002, <strong>Giant Diablo</strong> (e. Supergill) 2004, <strong>Lie Detector</strong> (e. Varenne) 2008, <strong>Calamara Donna</strong> (e. Pine Chip) 2009, <strong>Tamla Celeber</strong> (e. Cantab Hall) 2011, <strong>Diana Zet</strong> (e. Hard Livin) 2020, <strong>Honey Mearas</strong> (e. Readly Express) 2021, <strong>Kinglet Bird</strong> (e. Nuncio) 2024 och <strong>La Yuca</strong> (e. Face Time Bourbon).</p>



<p>Stig H Johansson triumferade sju gånger. Stig H vann med sex egentränade ston <strong>Holly Rodney</strong> (e. Captain Rodney) 1977, <strong>Gina Roy</strong> (e. Speedy Min) 1988, <strong>Queen L. </strong>(e. Crowntron) 1990, <strong>Bowls Lady</strong> (e. Super Bowl) 1991, <strong>Fiona San</strong> (e. Tibur) 1995 och <strong>Je T’aime Dream</strong> (e. Sugarcane Hanover) 2003, samt lånestyrningen <strong>Varia</strong> (e. Frosted Yankee) 1981.</p>



<p>Av årets kuskar har Björn Goop vunnit tre gånger (<strong>Carolinas Mystic, Sweet As Candy</strong> och <strong>Mellby Free</strong>), samt Carl Johan Jepson (<strong>Activated</strong>) och Johan Untersteiner (<strong>Neonas Princess</strong>) en gång. Övriga nio jagar första segern i loppet. </p>



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



<p class="has-drop-cap">Tolv finalister, men bara elva tränare. Eric Martinsson lyckades med konststycket att kvala in två ston till hemmabanans största lopp när <strong>Dats Bella </strong>(e. Power) vann sitt försök och <strong>Selmina Venit</strong> (e. Donato Hanover) grejade finalbiljett som tvåa.<br>– Ja, men det var ju härligt att det blev så här bra. Det är klart att man alltid har förhoppningar när man anmäler till försök, men man vet att det är så lite som krävs för att det ska krångla och ingen av dem var favoriter på spelet direkt, säger Eric Martinsson.</p>



<p>En av Axevallatränarens största framgångar kom när <strong>Thorn Bird</strong> (e. Clerk Magistrate) slutade trea i Stochampionatet.<br>– Vi var trea i Stochampionatet för elva år sedan och det är väl den högsta placering vi nått i ett klassiskt lopp så här långt. Alla vill vara med i de här loppen, man siktar dit, men så händer det saker som gör att man får revidera målen, säger Eric.</p>



<p><a href="https://sulkysport.se/det-stora-hemmahoppet/" target="_blank" rel="noreferrer noopener">––> Läs hela Sulkysports intervju med Eric Martinsson inför söndagen 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/07/miladyjosselyn-1-617x333.jpg" alt="" class="wp-image-875062"/><figcaption class="wp-element-caption">Lutfi Kolgjini-tränade Milady Josselyn och Adrian Kolgjini. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">I Lutfi Kolgjinis digra och imponerande meritlista som travtränare finns triumfen i Stochampionatet redan 1998 med <strong>Simb Capi</strong> (e. Probe). 2018 gjorde Lutfi sin sista säsong som proffstränare, men han har gjort comeback i mindre skala – med amatörlicens.<br>Han har ultrastammade <strong>Milady Josselyn</strong> (e. Ready Cash) i sin träning och stoet var trea i Drottning Silvias Pokal, men galopperade i Stosprinterns final. Det repade hon sig snabbt ifårn när det blev imponerande vinst i Stochampionatskvalet.</p>



<p>Miladys mamma <strong>Uza Josselyn</strong> (e. Love You-Teza Josselyn), 1.08,7ak/€1.278.078, är Danmarks vinstrikaste travare genom tiderna. Stoet vann 33 lopp på 79 starter och nämnas kan Gran Premio della Nazione, Sto-EM, Årjängs Stora Sprinterlopp, Prix de Chateaudun, Prix du Plateau du Gravelle, Prix de Washington och Grand Prix Anjou Maine.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/09/10purestella-617x333.jpg" alt="" class="wp-image-773081"/><figcaption class="wp-element-caption">Pure Stella och Jorma Kontio. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Readly Express och Ready Cash har redan gjort det. Haft en vinnare av Stochampionatet som pappa alltså. Nu har de chansen att fördubbla segerskörden. Readly Express var pappa till 2021 års vinnare <strong>Honey Mearas</strong> och ställer nu hoppet till <strong>Pure Stella</strong>.<br>Ready Cash fick sin triumf som far när <strong>Great Skills</strong> slog till året efter. Nu tittar den franske championhingsten ned från hästhimlen på dottern <strong>Milady Josselyn</strong>.</p>



<p>Hela sju avelshingstar har sin första startande avkomma i Stochampionatet i årets upplaga och en av dem har till och med dubbla chanser. Evighetsmaskinen <strong>Don Fanucci Zet</strong> (e. Hard Livin), 1.07,6ak/24.659.187 kr, tillbringar själv söndagen i finska Mikkeli för att slåss om segern i Grupp I-loppet S:t Michel Ajo, medan hans döttrar <strong>Pamela Boko</strong> och <strong>Jiovanha Falkone</strong> jagar klassisk seger på svensk mark efter att båda vunnit sina försök.<br>Detta är också Don Fanucci Zets första kull som avelshingst och den innehåller 50 svenskfödda fyraåringar.</p>



<p>Även <strong>Power</strong> (e. Googoo Gaagaa), 1.09,9am/12.010.376 kr, har sin första kull fyraåringar på banan och ur den skaran har <strong>Dats Bella</strong> nått Stochampionatet via seger i försöket.</p>



<h2 class="wp-block-heading">Avelshingstarnas resultat</h2>



<p><em>Avelshingst (antal i final 2026) – Tidigare finalister (resultat)</em></p>



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



<li><strong>Donato Hanover</strong> (1) – 3 – D’One (4) 2014, Zeta Kronos (0) 2019, Sayonara (6) 2021</li>



<li><strong>Readly Express</strong> (1) – 8 – <strong>Honey Mearas</strong> (1) 2021, Helluva Am (0) 2021, Tilda Express (0) 2021, Aurelia Express (5) 2023, Farina (2) 2024, Daim Brodda (3) 2024, Queen of Power (0) 2024, S.G. Empress (3) 2025</li>



<li><strong>Ready Cash</strong> (1) – 11 – Maya Gold (2) 2015, Steady Brodda (0) 2015, Caresse (6) 2016, Darling Hornline (0) 2016, Swish Lane (0) 2016, Cash Crowe (0) 2017, Fantasy River (0) 2017, Dibaba (0) 2018, <strong>Great Skills</strong> (1) 2022, Felicia Zet (3) 2022, Jurista (0) 2023</li>
</ul>



<p><strong>Don Fanucci Zet</strong> (2), <strong>Bar Hopping</strong> (1), <strong>Flocki d’Aurcy</strong> (1), <strong>Greenshoe</strong> (1), <strong>Muscle Mass</strong> (1), <strong>Power</strong> (1) och <strong>Robert Bi</strong> (1) har inte haft startande avkommor i Stochampionatet tidigare. </p>



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



<p class="has-drop-cap">Ingen av finalisternas morfäder har tidigare haft vinnare i Stochampionatet. Ready Cash har lyckats bäst med en andraplats genom <strong>Jennifer Sisu</strong> (e. Propulsion-Altesse Bourbon) 2023. I år försvarar dottern <strong>Pure Athena</strong> hans färger och Ready Cash är dessutom pappa till <strong>Milady Josselyn</strong>.</p>



<p>Trixton (<strong>Jiovanha Falkone</strong>), Fast Photo (<strong>Candie Lock</strong>) och Love You (<strong>Milady Josselyn</strong>) har sin första barnbarn i final i Stochampionatet.  </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/05/kreivimarkoriita260509adamstromstalltz-617x477.jpg" alt="" class="wp-image-848174"/><figcaption class="wp-element-caption">Marko och Riita Kreivi. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap">Uppfödaren och hästägaren Marko Kreivi upplevde sitt livs dag på travbanorna när hans hästar <strong>Pure Athena</strong> (e. Bar Hopping) och <strong>Pure Count</strong> (e. Googoo Gaagaa) vann Drottning Silvias Pokal respektive Kungapokalen på Åby i maj.</p>



<p>I Stochampionatet är Pure Athena tillbaka och hon får sällskap av en annan Kreivi-uppfödning i <strong>Pure Stella</strong> (e. Readly Express).<br>För två år sedan slutade Kreivis <strong>Pure Diamond</strong> (e. Father Patrick) sexa. Nu kan det bli bättre upp.</p>



<p>Marko Kreivi äger också fortsatt de båda Stochamnpionatsfinalisterna genom Göteborg Smart Repair Center AB. Även Bengt-Göran Lagestig, Ljungby (<strong>Dats Bella</strong>), AB Svensk Reklamfinans/SRF Stable (<strong>True Identity</strong>) och Stall Courant (<strong>Meditate</strong>) har kvar uppfödningarna i sin ägo.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/07/pamelaboko-1-617x333.jpg" alt="" class="wp-image-875065"/><figcaption class="wp-element-caption">Timo Nurmos-tränade Pamela Boko och Magnus A Djuse. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Dubbla uppfödningar har också John Bootsman och hans Boko Stables Holland BV, Nederländerna. Detta i form av <strong>Palema Boko</strong> (e. Don Fanucci Zet) och <strong>Peggy Boko</strong> (e. Robert Bi). 2007 tog Boko-uppfödningen <strong>Vala Boko</strong> (e. Alf Palema) hem de fyraåriga stonas största lopp. Timo Nurmos tränade, precis som han gör med Pamela Boko i år.</p>



<p>Menhammar Stuteri är bäst i klassen med tre uppfödda vinnare i <strong>Lie Detector</strong> (e. Varenne), <strong>Ultra Bright</strong> (e. Zola Boko) och <strong>Activated</strong> (e. Jocose), men saknar deltagare i år.</p>



<p><a href="https://sulkysport.se/stochampionatet-drommen-slog-in/" target="_blank" rel="noreferrer noopener">––> Läs mer om Selmina Venits uppfödare Linda och Mathias Paulsen här!</a></p>



<p><strong>Uppfödare i Stochampionatet</strong></p>



<ol class="wp-block-list">
<li>Pamela Boko – Boko Stables Holland BV, Nederländerna</li>



<li>Dats Bella – Bengt-Göran Lagestig, Ljungby</li>



<li>Love To The Limit – Mike Lenders, Frankrike</li>



<li>Milady Josselyn – S.C.E.A. Ecurie Bernard Yvan, med flera</li>



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



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



<li>Selmina Venit – Mathias &#038; Linda Poulsen </li>



<li>True Identity – AB Svensk Reklamfinans, Halmstad</li>



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



<li>Candie Lock – Stall Safety Lock HB, Lidköping</li>



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



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



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



<p class="has-drop-cap">Bara två av Stochampionatsfinalisterna har bytt ägare på auktion, men ytterligare tre har varit uppe i auktionsringen. Dyrast är <strong>Love To The Limit</strong> (e. Bold Eagle), som kostade 340.000 kronor på Solvalla Yearling Sale som ettåring. <br>Samma år ropade Daniel Redén och Stall Zet in <strong>Jiovanha Falkone</strong> (e. Don Fanucci Zet) för 100.000 kronor på Criterium Sale.</p>



<p><strong>Peggy Boko</strong> och <strong>Pure Stella</strong> var strukna från Elitauktionen. <strong>Selmina Venit</strong> ropades åter för 120.000 kronor på Travera som treåring den 12 juli ifjol.</p>



<p>Jiovanha Falkone är uppfödd av Ulf Lindström, som då och då dyker upp i spalterna och på Sulkysports hemsida med historiska återblickar, statistik, tankar och funderingar runt travsporten. Speciellt på andra sidan Atlanten.</p>



<p>Det var också där – på auktionen i Lexington – Lindström hittade Stochampionatsfinalistens mamma <strong>Kid Gloves</strong> (e. Trixton), 1.20,2m/28.500 kr, för 10.000 dollar. Kid Gloves gjorde fyra starter innan avelsboxen väntade. Jiovanha Falkone är första avkomman, treåriga stoet <strong>Oy Vey</strong> (e. Captain Corey), 1.14,3ak/118.000 kr, den andra.<br>Kid Gloves stamtavla bygger på superstoet <strong>Amour Angus</strong> (e. Magna Force) – mamma till avelshingstarna Andover Hall, Angus Hall, Conway Hall, Adams Hall och stoet Emelie Cas El. Amour Angus är både farmors mor och mormors mor till Kid Gloves.</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/07/meditate-617x333.jpg" alt="" class="wp-image-875068"/><figcaption class="wp-element-caption">Stefan P Pettersson-tränade Meditate och Mats E Djuse. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">På hästägarsidan ståtar Stall Zet ståtar med två segrar: <strong>Diana Zet</strong> (e. Hard Livin) och <strong>Honey Mearas</strong> (e. Readly Express). Detta kan fyllas på med en tredje genom <strong>Jiovanha Falkone</strong> (e. Don Fanucci Zet).</p>



<p>Stall Courants röda dress med gul hästsko på ryggen satt på Örjan Kihlström när <strong>Tamla Celeber</strong> (e. Cantab Hall) vann 2011 års upplaga. Däremot stod inte Stall Courant som registrerad ägare vid tillfället utan Am Bloodstock II AB, Halmstad. Året efter skrevs Tamla Celeber över på Stall Courant.<br>I Stefan P Pettersson-tränade <strong>Meditate</strong> (e. Greenshoe) har Anders Ströms bolag en egenuppfödd finalist i årets Stochampionat. En uppfödarseger har även Courant/Am Bloodstock sedan tidigare i 2024 års vinnare <strong>Kinglet Bird</strong> (e. Nuncio)</p>



<p>Stall Palema firade stora framgångar i Stochampionatet i mitten av 1980-talet. Två av tre upplagor slutade med seger för en av Karl-Erik Benders hästar: 1985 vann <strong>Emelie Palema</strong> (e. Pershing) och två år senare <strong>Kristina Palema</strong> (e. Quick Pay).</p>



<p><strong>Hästägare i Stochampionatet</strong></p>



<ol class="wp-block-list">
<li>Pamela Boko – P.A.Mela Stable</li>



<li>Dats Bella – Bengt-Göran Lagestig, Ljungby</li>



<li>Love To The Limit – Stall FG – Ofcourse</li>



<li>Milady Josselyn – Lutfi Kolgjini AB, Veberöd</li>



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



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



<li>Selmina Venit – Stall Martinsson AB &#038; Nipo Ljungby AB</li>



<li>True Identity – SRF Stable</li>



<li>Jiovanha Falkone – Stall Zet</li>



<li>Candie Lock – Stall Ec AB (Thomas Dalborg) &#038; Lasse Lundin</li>



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



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



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



<p class="has-drop-cap">Bakom en framgångsrik häst står en duktig hästskötare. Tolv tjejer gör det dagliga arbetet med Stochampionatsfinalisterna och oavsett vinnare blir det första skötarvinsten i Stochampionatet för tjejen bakom stoet.</p>



<p><strong>Hästskötare i Stochampionatet</strong></p>



<ul class="wp-block-list">
<li>Saara Jaakonsaari – Pamela Boko </li>



<li>Alexandra Eklund Johansson – Dats Bella </li>



<li>Ida Lind – Love To The Limit </li>



<li>Jessy van der Berg – Milady Josselyn </li>



<li>Matilda Bergström – Pure Athena </li>



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



<li>Malin Martinsson – Selmina Venit </li>



<li>Emilia Roth – True Identity </li>



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



<li>Hannah Matikainen – Candie Lock </li>



<li>Janina Soronen – Pure Stella </li>



<li>Martina Lundin – Meditate</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 Stochampionatet								</h3>
<div class="content">
								<em>År/vinnare – Far – Mor – Körsven – Tränare – Tid</em></p>
<ul>
<li>1969 <strong>Goldhook</strong> – Tampiko – Goldie Fortuna – Gösta Nordin – Gösta Nordin – 1.24,2a</li>
<li>1970 <strong>Famita</strong> – Torg – Ethel Bulwark – Sven Karlsson – Sven Karlsson  – 1.22,8a</li>
<li>1971 <strong>Benti Ribb</strong> – Smokey Hanover – Benboe Söndergaard – Olle Elfstrand – Olle Elfstrand – 1.24,1a</li>
<li>1972 <strong>Erva Scout</strong> – Scout Master – Minerva – Olle Lindqvist – Olle Lindqvist – 1.23,4a</li>
<li>1973 <strong>Gaby Bulwark</strong> – Earl Bulwark – Gaby Will – Sören Nordin – Sören Nordin – 1.23,4a</li>
<li>1974 <strong>Therese Bunter</strong> – King Bunter – Duchesse Faune – Göran Kärrstrand – Göran Kärrstrand – 1.23,9a</li>
<li>1975 <strong>Fonians</strong> – Earl Bulwark – Ann Gay – Sören Nordin – Sören Nordin – 1.22,5a</li>
<li>1976 <strong>Sweet Janki</strong>  – Nagasaki – Laila Scott – Gunnar Wallberg – Gunnar Wallberg – 1.20,9a</li>
<li>1977 <strong>Holly Rodney</strong>  – Captain Rodney – Kickan Fast – Stig H Johansson – Stig H Johansson – 1.22,9a</li>
<li>1978 <strong>Baroness Hill</strong>  – Brother Hill – Pasodoble – Thomas Nilsson – Thomas Nilsson – 1.22,8a</li>
<li>1979 <strong>May Björn</strong>  – Björn – Harlans Gaily – Olle Goop – Alf Lindholm (a) – 1.19,8a</li>
<li>1980 <strong>Queensway</strong>  – The Prophet – Maria Folsted – Göran E Johansson – Bo Eriksson (a) – 1.21,2a</li>
<li>1981 <strong>Varia</strong> – Frosted Yankee – Imperia – Stig H Johansson – Kaj Widell – 1.17,3a</li>
<li>1982 <strong>Brilana</strong> – Net Profit – Bibbi Sweep – Erik Berglöf – Erik Berglöf – 1.19,4a</li>
<li>1983 <strong>Sweet Bear</strong> – Shatter Way – Kicki Bear – Olle Goop – Olle Goop – 1.18,2a</li>
<li>1984 <strong>Pay the Bill</strong> – Quick Pay – Rimmilli Truck – Sven-Gunnar Andersson – S-G Andersson – 1.17,2a</li>
<li>1985 <strong>Kristina Palema</strong> – Quick Pay – Haha Arden – Bo Näslund – Bo Näslund – 1.18,7a</li>
<li>1986 <strong>Intact</strong>  – Netted – Misty Sister – Olle Goop – Olle Goop – 1.18,6a</li>
<li>1987 <strong>Emilie Palema</strong> – Pershing – Haha Arden – Bo Näslund – Bo Näslund – 1.17,3a</li>
<li>1988 <strong>Gina Roy</strong>  – Speedy Min – Regina Roy – Stig H Johansson – Stig H Johansson – 1.17,3a</li>
<li>1989 <strong>Tamila Gloria</strong> – Glasgow – Lycka Me – Jim Frick – Olle Goop – 1.17,3a</li>
<li>1990 <strong>Queen L. </strong> – Crowntron – Attila L. – Stig H Johansson – Stig H Johansson – 1.16,8a</li>
<li>1991 <strong>Bowls Lady</strong> – Super Bowl – Lady Lexington – Stig H Johansson – Stig H Johansson – 1.16,6a</li>
<li>1992 <strong>Royaling</strong>  – Royal Prestige – Precious Glory – Örjan Kihlström – Tommy Hanné – 1.17,4a</li>
<li>1993 <strong>Ina Scot</strong> – Allen Hanover – Lovina Grefgård – Kjell P Dahlström – Kjell P Dahlström – 1.15,2a</li>
<li>1994 <strong>Lovely Godiva</strong> – Ideal du Gazeau – Keystone Gwen – Per-Olof Pettersson – Per-Olof Pettersson – 1.15,1a</li>
<li>1995 <strong>Fiona San</strong> – Tibur – Norleah Hanover – Stig H Johansson – Stig H Johansson – 1.16,1a</li>
<li>1996 <strong>Krossed Out</strong> – Super Arnie – Seven Of Diamonds – Hans-Owe Sundberg – M-Å Törnqvist (a) – 1.16,1a</li>
<li>1997 <strong>Carolinas Mystic</strong> – Karate Chop – Coventry Lobell – Björn Goop – Björn Goop – 1.15,8a</li>
<li>1998 <strong>Simb Capi</strong> – Probe – Cap and Tassel – Lutfi Kolgjini – Lutfi Kolgjini – 1.17,0a</li>
<li>1999 <strong>Princess V.</strong> – Zoot Suit – Can Can Tim – Olle Goop – Olle Goop – 1.16,9a</li>
<li>2000 <strong>Sweet As Candy</strong> – Smasher – Pretty I. – Björn Goop – Lars-Eric Magnusson – 1.17,3a</li>
<li>2001 <strong>Volita du Ling</strong> – Super Arnie – Valinda – Erik Adielsson – Tommy Hanné – 1.15,5a</li>
<li>2002 <strong>Pine Dust</strong> – Pine Chip – Web Dust – Örjan Kihlström – Stefan Hultman – 1.15,7a</li>
<li>2003 <strong>Je t’Aime Dream</strong> – Sugarcane Hanover – Je t´Aime Hornline – Stig H Johansson – Stig H Johansson – 1.14,5a</li>
<li>2004 <strong>Giant Diablo</strong> – Supergill – Giant Rhytm – Örjan Kihlström – Roger Walmann – 1.15,7a</li>
<li>2005 <strong>Fama Currit</strong> – Viking Kronos – Union Madigan – Peter Ingves – Petri Puro – 1.15,5a</li>
<li>2006 <strong>Mad Marke</strong> – Vip Tilly – Madonna Hornline – Stefan Söderkvist  – Mikael Selin – 1.15,1a</li>
<li>2007 <strong>Vala Boko</strong> – Alf Palema – Flordalie – Jorma Kontio – Timo Nurmos – 1.14,4a</li>
<li>2008 <strong>Lie Detector</strong> – Varenne – Face Lifted – Örjan Kihlström – Stefan Hultman – 1.14,7a</li>
<li>2009 <strong>Calamara Donna</strong> – Pine Chip – Frosts Octopussy – Örjan Kihlström – Roger Walmann – 1.15,9a</li>
<li>2010 <strong>Viola Silas</strong> – Lindy Lane – Iza Silas – Fredrik Persson – Fredrik Persson – 1.15,9a</li>
<li>2011 <strong>Tamla Celeber</strong> – Cantab Hall – Amanda Celeber – Örjan Kihlström – Roger Walmann – 1.15,2a</li>
<li>2012 <strong>Drillbit Ås</strong> – Chocolatier – Perla d’Hilly – Åke Svanstedt – Svate Båth – 1.15,7a</li>
<li>2013 <strong>Blended Scotch</strong> – Super Photo Kosmos – Hopscotch – Per Linderoth – Per Linderoth – 1.13,2a</li>
<li>2014 <strong>Neona Princess</strong> – Gigant Neo – Dew Princess – Johan Untersteiner – Peter Untersteiner – 1.13,7a</li>
<li>2015 <strong>Some Summit</strong> – Dream Vacation – Graceland Summit – Veijo Heiskanen – Veijo Heiskanen – 1.13,6a</li>
<li>2016 <strong>Galactica</strong> – Super Photo Kosmos – Humla Laday – Lars-Åke Söderholm – Malin Bergström (a) – 1.13,2a</li>
<li>2017 <strong>Ultra Bright</strong> – Zola Boko – Patina – Fredrik Persson – Fredrik Persson – 1.13,0a</li>
<li>2018 <strong>Mellby Free</strong> – Muscle Hill – Mellby Ticket – Björn Goop – Björn Goop – 1.13,5a</li>
<li>2019 <strong>Activated</strong> – Jocose – Marelle – Carl Johan Jepson – Fredrik Wallin – 1.13,2a</li>
<li>2020 <strong>Diana Zet</strong> – Hard Livin – Maria Lb – Örjan Kihlström – Daniel Redén – 1.15,3a</li>
<li>2021 <strong>Honey Mearas</strong> – Readly Express – Khao Manee – Örjan Kihlström – Daniel Redén – 1.12,8a</li>
<li>2022 <strong>Great Skills</strong> – Ready Cash – Prowess Kronos – Daniel Wäjersten – Daniel Wäjersten – 1.12,5a</li>
<li>2023 <strong>Joy Sisu</strong> – Brillantissime – Southwind Eliza – Mika Forss – Petri Salmela – 1.12,3a</li>
<li>2024 <strong>Kinglet Bird</strong> – Nuncio – Vladzia Mauzun – Örjan Kihlström – Daniel Redén – 1.13,4a</li>
<li>2025 <strong>La Yuca</strong> – Face Time Bourbon – Komigen Pippi – Örjan Kihlström – Daniel Redén – 1.12,9a</li>
</ul></div>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
