
<p class="has-drop-cap wp-block-paragraph">Nederländaren Paul Hagoort och Gävletränaren Fredrik Wallin tillhör tränarna som firat framgångar i de stora unghästloppen de senaste åren och båda har vunnit Drottningpokalen. Fredrik Wallins toppsto <strong>Activated</strong> (e. Jocose) segrade i 2019 års upplaga, medan Hagoort-tränade <strong>Chebba Mil</strong> (e. Readly Express) triumferade 2022.</p>



<p class="wp-block-paragraph">I årets upplaga av Drottning Silvias Pokal kommer de två i särklass mest meriterade stona – båda är dubbeliljonärskor – från Hagoorts respektive Wallins stall <strong>Gourmet d’Arc </strong>(e. Six Pack) och <strong>Pure Athena</strong> (e. Bar Hopping).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/05/4gourmetdarc3-617x333.jpg" alt="" class="wp-image-723117"/><figcaption class="wp-element-caption">Gourmet d&#8217;Arc och Robin Bakker kunde kontra till seger i Breeders Course-finalen förra året. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Italienska Gourmet d’Arc har firat sina stora framgångar på svensk mark. Som tvååring vann hon Breeders Course-final på Jägerso och det följde hon upp med ny finalseger i finalen över medeldistans på Solvalla på Elitloppsdagen. Hon kvalade även in till Breeders Crown efter segrar i försök och semifinal på höstkanten.<br>Däremot finns också två plumpar. I både långa E3-finalen och Breeders Crown-diton slutade hon i den slagna skaran som oplacerad.</p>



<p class="wp-block-paragraph">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. Att hon är tillbaka på allvar visades i segern i forsöket.</p>



<p class="wp-block-paragraph">Gourmet d’Arc och Pure Athena har mötts tre gånger tidigare med fördel för Hagoorts sto: 2–1. </p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/06/pureathenafw1-617x333.jpg" alt="" class="wp-image-736818"/><figcaption class="wp-element-caption">Fredrik Wallin och Pure Athena? Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<h2 class="wp-block-heading">Startlista Drottning Silvias Pokal</h2>



<p class="wp-block-paragraph">Fyraåriga ston<br><strong>Priser: </strong>1.000.000-500.000-250.000-120.000-80.000-50.000 kr<br>2.140 meter autostart.</p>



<p class="wp-block-paragraph"><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li><strong>Gourmet d’Arc</strong> (e. Six Pack) – Robin Bakker (Paul Hagoort)</li>



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



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



<li><strong>Ursula</strong> (e. Mosaique Face) – Adrian Kolgjini</li>



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



<li><strong>Grace Vendil</strong> (e. Flocki d’Aurcy) – Björn Goop (Oskar Kylin Blom)</li>



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



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



<li><strong>Slipstream Zon</strong> (e. Googoo Gaagaa) – Dwight Pieters (Maria Törnqvist)</li>



<li><strong>Jacqueline Zet</strong> (e. Googoo Gaagaa) – Örjan Kihlström (Daniel Redén)</li>



<li><strong>Nyharajah</strong> (e. Maharajah) – Thomas Dalborg (Henrik Nyberg)</li>



<li><strong>Global Gaiety</strong> (e. Face Time Bourbon) – Johan Untersteiner</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">För första gången ingår Drottning Silvias Pokal i premiechansen, vilket betyder dubbla prispengarna till de svenskfödda fyraåringar som är med i premiechansen. Vinnaren kvitterar i så fall ut 1,5 miljon kronor. Samtliga elva svenskfödda ston slåss om det saftiga förstapriset, medan Paul Hagoorts italienska Gourmet d’Arc (e. Six Pack) ”bara” får tävla om en segercheck på 1.000.000 kronor.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/11/lutfikolgjiniportr2-617x333.jpg" alt="" class="wp-image-386457"/><figcaption class="wp-element-caption">Lutfi Kolgjini. Foto Jeannie Karlsson/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">I Lutfi Kolgjinis digra och imponerande meritlista som travtränare finns triumfen i Drottning Silvias Pokal 2016 med <strong>Princess Face</strong> (e. Muscle Hill), som kördes av Björn Goop. Två år senare gjorde Lutfi sin sista stora säsong som proffs innan sonen Adrian tog över ansvaret och tränarrörelsen. Det gav bland annat seger i Drottningpokalen för två år sedan med <strong>Karaboudjan</strong> (e. Walner) med domarchefen Erik Adielsson i vagnen.</p>



<p class="wp-block-paragraph">”Ludde” har gjort comeback i mindre skala – som amatörtränare! – och nu blir det ett storloppsmöte mellan far och son!<br>Pappa Kolgjini har ultrastammade <strong>Milady Josselyn</strong> (e. Ready Cash) i sin träning, medan Adrian mönstrar <strong>Ursula</strong> (e. Mosaique Face) och båda hästarna vann sina försök.<br>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>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/09/8ursula-617x333.jpg" alt="" class="wp-image-773061"/><figcaption class="wp-element-caption">Ursula och Adrian Kolgjini. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">En som har järnkoll på båda hästarna är Dante Kolgjini, som kör pappas häst och arbetar hos storebror Adrian.<br>– Mylady Josselyn var jättefin senast och hon tillhör de bättre i fältet rent kapacitetsmässigt. Sedan måste hon tyvärr gå med bakskor den här gången. Det är helt klart ett minus, men vi får hoppas att det kan gå ändå, säger Dante Kolgjini till Kanal75.</p>



<p class="wp-block-paragraph">Ursula gjorde första starten för året i Drottningkvalet. Ifjol imponerade hon bland annat vid vinst i Oakskvalet.<br>– Det var en mycket bra årsdebut. Hon behövde det och tränar ännu bättre efteråt. Det känns som att hon börjar närma sig riktigt storform. Sedan måste det klaffa och sådär i loppen också, det är inte helt lätt att vinna Grupp I-lopp, säger Dante Kolgjini.</p>



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



<p class="has-drop-cap wp-block-paragraph">Första B-tränaren att plocka fram en vinnare i loppets 43-åriga historia var Solvallaamatören Lennart Wikström som i <strong>Simb Capi</strong> (e. Probe) skapade en riktig toppmärr. På hästen som treåring vann hon både Svenskt Trav-Oaks och Breeders Crown och fyraåringssäsongen fick en flygande start med segrar i Ina Scots Ära och Drottningpokalen. När hon vann det sistnämnda loppet var det tionde raka (!) triumfen.</p>



<p class="wp-block-paragraph">Inför Stochampionatet i juli såldes Simb Capi till tyske storhästägaren Michael Schröer och i Lutfi Kolgjinis regi plockades även Axevallas storlopp hem. Efter galopp i kval till Svenskt Travderby. spelad till tolv för tio – slutade Simb Capi tvåa i italienska storloppet Gran Premio Continentale i Kolgjinis regi innan Simb Capi lämnade Sverige för att fortsätta tävlingskarriären i Tyskland hos privattränaren Veijo Kivioja.</p>



<p class="wp-block-paragraph">63 starter (29–7–6), 1.11,5ak*/4.950.361 kr, blev facit för Simb Capi som gjorde sin sista start som åttaåring 2002.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/04/jovialityeam230421adamstromstalltz-617x379.jpg" alt="" class="wp-image-434137"/><figcaption class="wp-element-caption">Joviality vinner Drottningförsöket för Erik Adielsson. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">2023 fick Wikström sällskap när Sabine Kagebrant tränade <strong>Joviality</strong> (e. Chapter Seven). Kort efter triumfen på Åby blev Sabine proffstränare och bytte B till A.</p>



<p class="wp-block-paragraph">Blir Lutfi Kolgjini näste amatör i raden – eller blir det kanske Axevallas Henrik Nyberg? 70-åringen har två hästar på träningslistan, finalisten <strong>Nyharajah</strong> (e. Maharajah) och hennes två år äldre storasyster Nyatrix (e.Trixton), 1.15,0m*/230.000 kr. Nyharajah har vunnit ett lopp hittills, i ett försök i stodivisionen på hemmaplan i februari.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/05/pantheredinverneaem250503adamstromstalltz-617x368.jpg" alt="" class="wp-image-714729"/><figcaption class="wp-element-caption">Panthere d&#8217;Inverne och André Eklundh vid segern i Drottning Silvias Pokal i våras. Foto: Adam Ström/stalltz.se<br></figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Ytterligare två av tränarna bakom finalhästarna vet hur det känns att vinna Drottning Silvias Pokal. 2020 blev Daniel Redén-tränade <strong>Diana Zet</strong> (e. Hard Livin) drottning på Åby och ifjol var det hemmatränaren André Eklundhs stora stund när <strong>Panthere d’Inverne</strong> (e. Brillantissime) plockade hem segermiljonen.</p>



<p class="wp-block-paragraph">Duon kommer med varsin häst som har liknande bakgrund. Både Eklundhs <strong>Princessofthedawn</strong> (e. Maharajah) och Redéns <strong>Jacqueline Zet</strong> (e. Googoo Gaagaa) har gjort tolv starter, tjänat över 400.000 kronor och slutade tvåa i sina uttagningslopp.</p>



<p class="wp-block-paragraph">– Princessofthedawn känns bara uppåt hemma och ska ha toppform nu. Hon har fått två lopp och normalt när mina hästar gör tredje starten så är dom på topp. Det ser tufft ut, men jag hoppas komma ned till plankan och tar det därifrån, sade André Eklundh till V65 Direkt.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/07/dianazetokm210725adamstromstalltz-617x397.jpg" alt="" class="wp-image-190743"/><figcaption class="wp-element-caption">Diana Zet och Örjan Kihlström. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Örjan Kihlström och Johnny Takter har flest kusksegrar i Drottninghistorien och båda ståtar med fem triumfer vardera. Totalt har Örjan kört finalen 33 gånger från debuten 1990 med egentränade <strong>Play Around</strong> om slutade tvåa. <strong>Giant Diablo, Lie Detector, Tamla Celeber, Dibaba</strong> och <strong>Diana Zet</strong> har Örjan styrt till vinst. I år kör han <strong>Jacqueline Zet</strong> (e. Googoo Gaagaa).</p>



<p class="wp-block-paragraph">Johnny Takter har inte kört finalen sedan han segrade med <strong>Cash Crowe</strong> (e. Ready Cash) för nio år sedan. Hans övriga vinnarhästar är <strong>Blues Office, Birminghim, Backfire</strong> och <strong>Ruby Trap.</strong></p>



<p class="wp-block-paragraph">Bakom Kihlström och Takter skuggar domarbasen Erik Adielsson med fyra vinster efter att ha segrat två år i rad med Stall Courant-ägda ston: 2023 med Sabine Kagebrant-tränade <strong>Jovility</strong> och bakom Adrian Kolgjini-tränade <strong>Karaboudjan</strong> året efter. Eriks övriga vinnare är <strong>Sweet As Candy</strong> 2000 och <strong>Lotuschic</strong> 2006.</p>



<p class="wp-block-paragraph">Av kuskarna i årets final har, förutom Kihlström, fyra körsvenner vunnit finalen: Robin Bakker vann med Paul Hagoort-tränade <strong>Chabba Mil</strong> (e. Readly Express) för tre år sedan och kör <strong>Gourmet d’Arc</strong> (e. Six Pack) åt samme tränare i år. Björn Goop styrde <strong>Princess Face</strong> åt Lutfi Kolgjini 2016 och har Oskar Kylin Bloms <strong>Grace Vendil</strong> (e. Flocki d’Aurcy) i år. Carl Johan Jepson har en seger med <strong>Activity</strong> 2019 och kör nu Fredrik Wallins <strong>Pure Athena</strong> (e. Bar Hopping) – och så André Eklundh som efter fjolårstriumfen med <strong>Panthere d’Inverne</strong> (e. Brillantissime) laddat om med <strong>Princessofthedawn</strong> (e. Maharajah).</p>



<p class="wp-block-paragraph"><strong>Segerrikaste kuskar i Drottningpokalen:</strong></p>



<ul class="wp-block-list">
<li>Fem segrar: Örjan Kihlström, Johnny Takter</li>



<li>Fyra segrar: Erik Adielsson</li>



<li>Tre segrar: Robert Bergh, Olle Goop</li>



<li>Två segrar: Stig H Johansson, Bo Näslund, Åke Svanstedt</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">3 uppfödare har tagit två vinster. Ellert Larsson, Sigtuna, var mannen bakom <strong>Drottning Sund</strong> (e. Tobus) och <strong>Itaka Sund</strong> (e. Sugarcane Hanover), medan två av sex vinnande USA-importer kom från Perretti Farms, nämligen <strong>Love n’Hate </strong>(e. Muscles Yankee) och <strong>Ruby Trap</strong> (e. Explosive Matter).</p>



<p class="wp-block-paragraph">Am Bloodstock har fött upp två av de senaste tre årens vinnare <strong>Joviality</strong> (e. Chapter Seven) och <strong>Karaboudjan</strong> (e. Walner).<br>Årets hopp för Stall Courant (Anders Ström) är egenuppfödda <strong>Meditate</strong> (e.Greenshoe), som tränas av Mantorps Stefan P Pettersson.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/02/globalgaietypum260207adamstromstalltz-617x392.jpg" alt="" class="wp-image-817671"/><figcaption class="wp-element-caption">Global Gaiety vinner stodivisionen för Peter Untersteiner. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">I årets upplaga har uppfödare har två chanser. Hans Nelén kan se två uppfödningar från Global Farm i form av <strong>Global Good News</strong> (e. S.J.’s Caviar) och <strong>Global Gaiety</strong> (e. Face Time Bourbon).</p>



<p class="wp-block-paragraph">Global Good News hade en fin treåringssäsong hos Andreas Lövdal med tredjeplatsen i Breeders Crown-finalen som främsta merit. Johan Untersteiner-tränade Global Gaiety har tagit sina stora steg i vinter coh vår med framgångar i rikstoton, där hon vann försök och final i stodivisionen i årets första meeting.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/09/6slipstreamzon-617x333.jpg" alt="" class="wp-image-773057"/><figcaption class="wp-element-caption">Utvändiga Slipstream Zon och Carl Johan Jepson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Tre av finalisterna har varit ute på auktion som unghästar och två av dem har sålts på dessa. På italienska ITS-auktionen ropades <strong>Gourmet d’Arc</strong> (e. Six Pack) in för 31.000 euro, medan <strong>Slipstream Zon</strong> (e. Googoo Gaagaa) ropades in för 60.000 kronor av Petras HB på Åby Yearling Sale.</p>



<p class="wp-block-paragraph">Båda hästarna vann sina försök och Slipstream Zon har visat framhovarna hela karriären. Förra året vann hon uttagningslopp till Svenskt Trav-Oaks och slutade sedan femma i finalen. Slipstream Zon är lillasyster till miljonären <strong>Jimbaran Zon</strong> (e. Maharajah), som numera tävlar på amerikansk mark.<br>– Slipstream Zon har tränat fint efter försöket och är inte sämre än då. Vi får fundera på vilken rygg vi väljer, om det blir innerspår ett andraspår. Hästen känns jättefin och det fanns kvar över mål i kvalet, då det är en bra känsla inför finalen, sade Dwight Pieters till V65 Direkt.</p>



<p class="wp-block-paragraph">Uppfödarna Torbjörn och Madelen Ohlzon har firat framgångar i Drottningpokalen tidigare genom <strong>O’Mara Zon</strong> (e. Maharajah), som slutade trea för tre år sedan.</p>



<p class="wp-block-paragraph"><strong>Nyharajah</strong> (e. Maharajah) ropades åter för 200.000 kronor på Elitauktionen. </p>



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



<p class="has-drop-cap wp-block-paragraph">Mest rutinerad av finalisterna är Oskar Kylin Bloms hopp <strong>Grace Vendil</strong> (e. Flocki d’Aurcy), som hunnit med 19 starter inför finalen. En av dessa har slutat med seger, i Hästägarepokalen i Visby i somras.<br>Grace Vendil var igång tidigt och debuterade redan i augusti som tvååring med en tredjeplats på Solvalla. Främsta meriten kom sent i höstas när hon slutade tvåa bakom en av finalmotståndarna <strong>Pure Athena</strong> (e. Bar Hooping) i E3-revansch för ston.</p>



<p class="wp-block-paragraph">I andra änden – nio starter innanför västen har Maria Törnqvists <strong>Slipstream Zon</strong> (e. Googoo Gaagaa), som är minst rutinerad.</p>



<p class="wp-block-paragraph">Fyra finalister tävlade som tvååringar. Förutom Grace Vendil även <strong>Gourmet d’Arc, Pure Athena</strong> och <strong>Ursula</strong>.</p>



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



<p class="has-drop-cap wp-block-paragraph">Frankrikes dominerande avelshingst under ett decennium, Ready Cash, lämnade jordelivet 2023, men fortsätter att göra stora avtryck som fadershingst. 2025 tog han sitt tionde raka hingstchampionat i Frankrike och var över en miljon euro före tvåan, sonen Face Time Bourbon.</p>



<p class="wp-block-paragraph">I Drottningpokalens historia kan han se tillbaka på två vinnare på sju försök i Cash Crowe och Dibaba. Nu ställer Ready Cash hoppet till Milady Josselyn.</p>



<p class="wp-block-paragraph"><strong>Avelshingstar i Drottning Silvias Pokal:</strong><br><em>Avelshingst (finalist 2025) – Tidigare finalister – Resultat</em></p>



<ul class="wp-block-list">
<li><strong>Face Time Bourbon</strong> (1) – 2 – Naomi Bros (4) 2024, Arctic Angel (4) 2025</li>



<li><strong>Maharajah</strong> (2) – 13 – Felicity Shagwell (0) 2019, Intake (0) 2019, Zeta Wise As (0) 2019, Nikita Sunrise (0) 2021, Stella Nova Race (0) 2021, Deborah S.H. (2) 2022, Kayla Westwood (2) 2023, O’Mara Zon (3) 2023, Mellby Korall (4) 2023, Riverdale Z. (0) 2023, Sommerbrise (0) 2023, Staro Raili (0) 2024, Elegance Silvio (3) 2025</li>



<li><strong>Ready Cash</strong> (1) – 7 – Cash Crowe (1) 2017, Caddie Lisieux (0) 2017, Dixi Sisu (0) 2017, Dibaba (1) 2018, Grande Diva Sisu (2) 2020, Donna Summer (0) 2022, Jade Sisu (0) 2023</li>



<li><strong>S.J.’s Caviar</strong> (1) – 4 – Global Upper Style (2) 2018, Conrads Rödluva (2) 2019, Olga Tooma (0) 2022, Matchmadeinheaven (str) 2025</li>
</ul>



<p class="wp-block-paragraph"><strong>Googoo Gaagaa</strong> (2), <strong>Bar Hopping</strong> (1), <strong>Flocki d’Aurcy</strong> (1), <strong>Greenshoe</strong> (1), <strong>Mosaique Face</strong> (1) och <strong>Six Pack</strong> (1) har sina första finalister i Drottning Silvias Pokal.</p>



<p class="wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/01/readycashprisflores-617x333.jpg" alt="" class="wp-image-678483"/><figcaption class="wp-element-caption">Constanza Flores när det begav sig som skötare till självaste Ready Cash hos Philippe Allaire. <br>Foto Gerard Forni</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Förra året var Constanza Flores skötare till vinnaren <strong>Panthere d’Inverne</strong> (e. Brillantissime), tränad av André Eklundh, i Drottningpokalen. I årets upplaga är den forna skötaren till Ready Cash med igen. Den här gången heter Constanzas hopp <strong>Princessofthedawn</strong> (e. Maharajah).</p>



<p class="wp-block-paragraph"><strong>Här är skötarna bakom finalisterna:</strong></p>



<ul class="wp-block-list">
<li>Gourmet d’Arc – Demi Veenstra</li>



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



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



<li>Ursula – Anna Olsson</li>



<li>Meditate – Martina Lundin</li>



<li>Grace Vendil – Hanna Reiser</li>



<li>Princessofthedawn – Constanza Flores</li>



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



<li>Slipstream Zon – Johannes Karlsson</li>



<li>Jacqueline Zet – Joline Kjellstrand</li>



<li>Nyharajah – Per Hurtsén</li>



<li>Global Gaiety – Isabel Esper</li>
</ul>


<div class="factbox full minify">
<div class="insidefactbox">
<div class="overflow">
<div class="height">
<div class="padding">
<div class="factvinjett">Fakta</div>
<h3 class="title">
									Drottning Silvias Pokal 1983-2025								</h3>
<div class="content">
<p class="wp-block-paragraph"><em>År/segrare – Far – Körsven – Tränare – Segertid</em></p>
<p class="wp-block-paragraph">1983 <strong>Sussi Håleryd</strong> – Garry Håleryd – Ulf Nordin – Ulf Nordin – 1.16,4a<br />1984 <strong>Mariana W.</strong> – Scout Master – Olle Goop – Lars-Göran Carlsson (a) – 1.16,3a<br />1985 <strong>Kristina Palema</strong> – Quick Pay – Bo Näslund – Bo Näslund – 1.15,9a<br />1986 <strong>Intact</strong> – Netted – Olle Goop – Olle Goop – 1.17,4a<br />1987 <strong>Lass Dame</strong> – Quick Pay – Bo Näslund – Bo Näslund – 1.18,0a<br />1988 <strong>Gina Roy</strong> – Speedy Min – Stig H Johansson – Stig H Johansson – 1.17,0a<br />1989 <strong>Viva Mon</strong> – Super Mon – Åke Lindblom – Åke Lindblom – 1.16,5a<br />1990 <strong>Drottning Sund</strong> – Tibur – Björn Larsson – Björn Larsson – 1.15,3a<br />1991 <strong>Bowls Lady</strong> – Super Bowl – Stig H Johansson – Stig H Johansson – 1.17,2a<br />1992 <strong>Iata Käll</strong> – Ata Star L. – Jim Frick – Tommy Hanné – 1.16,6a<br />1993 <strong>Ina Scot</strong> – Allen Hanover – Kjell P Dahlström – Kjell P Dahlström – 1.14,9a<br />1994 <strong>Serena</strong> – Nuclear Kosmos – Christer Nylander – Christer Nylander – 1.15,2a<br />1995 <strong>Itaka Sund</strong> – Sugarcane Hanover – Fredrik B Larsson – Björn Larsson – 1.16,7a<br />1996 <strong>Sacrifice</strong> – Quick Pay – Olle Goop – Olle Goop – 1.16,6a<br />1997 <strong>Arnies Super Girl</strong> – Super Arnie – Dick S Jansson – Håkan Lindqvist (a) – 1.15,1a<br />1998 <strong>Simb Capi</strong> – Probe – Per Lennartsson – Lennart Wikström (a) – 1.16,0a<br />1999 <strong>Cindy Bob</strong> – Giant Chill – Mats Karlsson – Hans Karlsson – 1.16,3a<br />2000 <strong>Sweet As Candy</strong> – Smasher – Erik Adielsson – Lars-Eric Magnusson – 1.15,3a<br />2001 <strong>Hilda Zonett</strong> – Spotlite Lobell – Robert Bergh – Robert Bergh – 1.15,0a<br />2002 <strong>Blues Office</strong> – Foreign Office – Johnny Takter – Petri Puro – 1.15,2a<br />2003 <strong>Rae Boko</strong> – Pine Chip – Jorma Kontio – Markku Nieminen – 1.15,1a<br />2004 <strong>Giant Diablo</strong> – Supergill – Örjan Kihlström – Roger Walmann – 1.15,6ag<br />2005 <strong>Fama Currit</strong> – Viking Kronos – Peter Ingves – Petri Puro – 1.14,6a<br />2006 <strong>Lotuschic</strong> – Pine Chip – Erik Adielsson – Stig H Johansson – 1.14,5a<br />2007 <strong>Birminghim</strong> – Striking Sahbra – Johnny Takter – Harald Lunde – 1.13,6a<br />2008 <strong>Lie Detector</strong> – Varenne – Örjan Kihlström – Stefan Hultman – 1.13,6a<br />2009 <strong>Mystic Lady U.S.</strong> – Andover Hall – Robert Bergh – Åke Svanstedt – 1.13,7a<br />2010 <strong>Viola Silas</strong> – Lindy Lane – Fredrik Persson – Fredrik Persson – 1.12,9a<br />2011 <strong>Tamla Celeber</strong> – Cantab Hall – Örjan Kihlström – Roger Walmann – 1.13,0a<br />2012 <strong>Love n’Hate</strong> – Muscles Yankee – Åke Svanstedt – Åke Svanstedt – 1.14,2a<br />2013 <strong>Gisela Ås</strong> – Infinitif – Åke Svanstedt – Åke Svanstedt – 1.12,4a<br />2014 <strong>Backfire</strong> – Offshore Dream – Johnny Takter – Tomas Malmqvist – 1.12,6a<br />2015 <strong>Ruby Trap</strong> – Explosive Matter – Johnny Takter – Stefan Melander – 1.13,3a<br />2016 <strong>Princess Face</strong> – Muscle Hill – Björn Goop – Lutfi Kolgjini – 1.13,1a<br />2017 <strong>Cash Crowe</strong> – Ready Cash – Johnny Takter – Petri Puro – 1.12,7a<br />2018 <strong>Dibaba</strong> – Ready Cash – Örjan Kihlström – Roger Walmann – 1.11,4a<br />2019 <strong>Activated</strong> – Jocose – Carl Johan Jepson – Fredrik Wallin – 1.11,6a<br />2020 <strong>Diana Zet</strong> – Hard Livin – Örjan Kihlström – Daniel Redén – 1.12,6a<br />2021 <strong>Fifty Cent Piece</strong> – Muscle Hill – Robert Bergh – Robert Bergh – 1.12,6a<br />2022 <strong>Chebba Mil</strong> – Readly Express – Robin Bakker – Paul Hagoort – 1.11,7a<br />2023 <strong>Joviality</strong> – Chapter Seven – Erik Adielsson – Sabine Kagebrant – 1.12,4a<br />2024 <strong>Karaboudjan</strong> – Walner – Erik Adielsson – Adrian Kolgjini – 1.12,5a<br />2025 Panthere d&#8217;Inverne – Walner – André Eklundh – André Eklundh – 1.12,0a</p>
</p></div>
</p></div>
</p></div>
</p></div>
<div class="expand">
						<span class="text">Expandera</span><br />
						<span class="icon sprites"></span>
					</div>
</p></div>
</p></div>



<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="UouUY03hIc"><a href="https://sulkysport.se/den-svarslagna-komben/">Den svårslagna komben?</a></blockquote><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; visibility: hidden;" title="”Den svårslagna komben?” &ndash; Sulkysport" src="https://sulkysport.se/den-svarslagna-komben/embed/#?secret=HdCz8hmQU8#?secret=UouUY03hIc" data-secret="UouUY03hIc" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe>
</div></figure>
