
<p class="has-drop-cap">1Hästar som Sveriges vinstrikaste travare genom tiderna <strong>Victory Tilly</strong>, Prix de France-ettan med mera <strong>Naglo</strong>, Derbyvinnarna <strong>Hail Mary</strong> och <strong>Mustard</strong> och dessutom fyra vinnare av Svenskt Travkriterium: <strong>Oktan Sund, Allen Victory, Simb Zipper</strong> och <strong>Deimos Racing</strong>.<br>Alla har de plockat hem Kriterierevanschen på Solvalla på senhösten som treåringar.</p>



<p>Ikväll är det dags för årets upplaga och årets Kriterievinnare <strong>Bullet The Bluesky</strong> (e. Readly Express) lämnar fältet öppet för övriga sedan han i lördags slagit nytt världsrekord – 1.11,3a/2.140 meter – från dödens i Breeders Crown-finalen.</p>



<p>Två Kriteriefinalister dyker upp i revanschen, men duon <strong>Golden Sunrise</strong> (e. Readly Express) och <strong>Magic In</strong> (e. Face Time Bourbon) drog spår elva och tolv bakom bilen i långdistansloppet.<br>Den sistnämnde har vunnit försök tillbåde korta E3 och Kriteriet, men inte lyckats i finalerna.</p>



<p>Förhandsfavoriten är annars en extra revanschsugen travare. Ulf Stenströmer-tränade <strong>Conrads Åke</strong> (e. Perfect Spirit) tillhörde skaran treåringar som inte fick plats i kvalen (!) till Kriteriet, där han var utanför de 72 som fick starta på seedningslistan.<br>Samma öde drabbade Jerry Riordan-tränade <strong>Fighter Kronos</strong> (e. Muscle Hill), som vunnit två av fyra starter – dessutom tvåa och trea – sedan han han ”petades” ur Kriteriekvalen.</p>



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



<p class="has-drop-cap">2De treåriga stona gör upp om samma prischeck i Oaksrevanschen och även här saknas vinnaren under Kriteriehelgen. Oaksvinnaren <strong>Vivillion</strong> (e. Propulsion) startade också i BC-final i lördags, där hon tog fjärdeplatsen.</p>



<p>Två Oaksvinnare i historien har försvarat sin seger i Oaksrevanschen och det skedde två år i rad i slutet av 1990-talet, där <strong>Simb Capi</strong> (e. Probe) och <strong>Pine Princess</strong> (e. Napoletano) segrade. Två toppston med fler tunga titlar på meritlistan.<br>Två revanschvinnare i närtid som blev mångmiljonärskor är <strong>Activated</strong> (e. Jocose) och <strong>Imhatra Am</strong> (e. Muscle Hill), och även om Breeders Crown-vinnaren <strong>Olympia Tillys</strong> (e. Lindy Lane) prestationer på tävlingsbanan verkligen inte skäms för sig, så är hon ännu hetade i sin nya karriär – som fölsto och mamma till klassiska vinnarna Calgary Games och Fame And Glory!</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/09/matchmadeinheaven-617x333.jpg" alt="" class="wp-image-640188"/><figcaption class="wp-element-caption">Matchmadeinheaven vid seger i Oakskval. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Årets upplaga då? Vinstrikast i sällskapet är Svampenvinnaren och Oaksfinalisten <strong>Matchmadeinheaven</strong> (e. S.J.’s Caviar), som har sällskap av <strong>Ready To Run H.C.</strong> (e. Nuncio) och <strong>Tangerina</strong> (e. Perfect Spirit) från storloppsfinalen i mitten av oktober.<br>– Matchmadeinheaven har bra kapacitet och vann ett försök till Oaks, men fick inget med i finalen. Senast hamnade hon hamnade punschigt på det och uppträdde även lite trögt. Härifrån får hon smyga med och spurta till slut och se vad vi kan få, säger Fredrik Wallin om en av sina tre hästar i loppet.</p>



<p><a href="https://sulkysport.se/v86-passande-lage-for-caia-hon-ar-startsnabb/" target="_blank" rel="noreferrer noopener">Läs mer vad Gävletränaren tror om kvällens chanser här!</a></p>



<p>På V86-kupongen finns också snabbloppet Kentucky Fibbers lopp. Loppet var länge en ögonöppnare tidigt på våren över sprinterdistans med startbil. Victory Tilly vann till exempel tre upplagor och Scarlet Knight två i början av 2000-talet.<br>Sedan 2021 har loppet flyttat till hösten och distansen blivit ett halvvarv längre. I år blir det även premiär som spårtrappa med åttafaldiga miljonärerna <strong>Milliondollarrhymne</strong> (e. Ready Cash) och <strong>Brother Bill</strong> (e. From Above) från de sämsta startspåren.</p>



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



<p class="has-drop-cap">3Solvalla delar kvällens värdskap av V86 med norska Bjerke (första start 18.27). Årjängtränaren Paw Mahony reser med fjolårets vinnare av Malmö Stads Pris under Åbergskvällen, <strong>Millmighty</strong> (e. Make It Happen). Då handlade det om drygt tre kilometer, ikväll travar Millmighty halva distansen och ställs främst mot Frode Hamre-duon <strong>Canopus</strong> (e. Trixton) och <strong>Bunny</strong> (e. Born In The U.S.A.), som vunnit åtta respektive sex lopp i år. Millmighty gör sin 34:e start i karriären och har aldrig testat kort distans tidigare!</p>



<p>Ett kallblodslopp tar plats på kupongen och där startar en häst som verkligen vet hur man vinner travlopp. Femårige <strong>Bare Mattis</strong> (e. Alsaker Piril) har sex raka segrar och 18 vinster på 25 försök hittills i karriären inför kvällens uppgift tillsammans med ordinarie kusken Vidar Hop.</p>



<p>En intressant comeback – och årsdebut – gör femårige <strong>Patrick Palema</strong> (e. Muscle Hill) efter ett års uppehåll. Hästen tävlade som unghäst hos Åke Svanstedt i USA och vann tre av tio starter på nordisk mark förra året, däribland ett klass II-försök.</p>



<p><strong>Sulkysports spelstuga med viktiga punkter, spikar, drag och favoriter i fara publiceras som vanligt idag kl 12.00.</strong></p>



<p>Hos vår samarbetspartner Travnet finns andelar till kvällens V86-omgång på Högkvarteret.<br><a href="https://www.atg.se/hogkvarteret/V86_2024-11-20_40_1" target="_blank" rel="noreferrer noopener">Här är alla andelar!</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/2024/05/6veikkohaapakangas-617x333.jpg" alt="" class="wp-image-588509"/><figcaption class="wp-element-caption">Veikko Haapakangas. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">4Veikko Haapakangas, född 2000, leder i stor stil före Gustav Johansson, född 2003, i tränarligan för svenskar som är 25 år eller yngre. Haapakangas har fem STL-segrar i bagaget på vägen till de 3,6 miljoner stallets hästar sprungit in hittills i år.<br>Gustav Johansson har också STL-triumfer i år på meritlistan, och duon är ensamma av landets unga proffs- och amatörtränare att ha lyckats med detta.</p>



<p>När det gäller kuskar i samma ålderskategori har sex lyckats få sin styrning sätta nosen först i STL-sammanhang. Magnus A Djuse är en klass för sig med 58 vinster. Gustav Johansson (7), Malte Handfast (2), Dante Kolgjini (1), Linus Lönn (1) och Wilma Karlsson (1) är de övriga.</p>



<p><strong>Vinstrikaste svenska tränare – 25 år eller yngre</strong><br><em>Tränare, hemmabana – Född – Start/segrar – Prispengar</em></p>



<ol class="wp-block-list">
<li>Veikko Haapakangas, Åby – 2000 – 311/38 – 3.674.503 kr</li>



<li>Gustav Johansson, Halmstad – 2003 – 137/18 – 2.019.765 kr</li>



<li>Tilda Wahlberg, Boden – 2001 – 62/6 – 498.900 kr</li>



<li>Linn E Andersson, Umåker – 2000 – 65/6 – 412.600 kr</li>



<li>Tiffany Wistrand, Solvalla – 2001 – 47/5 – 299.894 kr</li>
</ol>



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



<p class="has-drop-cap">5I förra veckan kunde Sulkysport berätta att <strong>Qualmio de Vandel</strong> gått ur tiden. Nu har det också meddelats från Frankrike att hans far <strong>Gobernador</strong> (e. Buvetier d’Aunou-Tangala), 1.11,0ak*/€885.756, vandrat vidare till de evigt gröna ängarna. Han dog i sitt hem på Haras de Retz i Normandie.</p>



<p>Gobernador tävlade för framlidne Pierre-Désiré Allaire och var framgångsrik både framför sulky och under sadel. Hans stora år var 2001 och det året vann Buvetier d’Aunou-sonen Prix de France, Prix de Paris, Prix Atlantique och Grand Criterium de Vitesse. Största sadelsegern kom i semi-classique-löpningen Prix Paul Buquet 2000 och året efter slutade han tvåa i Prix de Cornulier. </p>



<p>I Frankrike finns det 812 registrerade avkommor efter Gobernador och tillsammans han de sprungit in 10,8 miljoner euro. Vinstrikast är <strong>Severino</strong> (€963.049) före Qualmio de Vandel (€685.300). Idag är Gobernador mest känd som farfar till årets Prix d’Amérique-vinnare <strong>Idao de Tillard</strong> (e. Severino), 1.09,4am*/€2.394.660.<br>Av hans 75 svenskregistrerade lyckades en passera sjusiffrigt; <strong>French Cocktail</strong>, 1.13,1am/2.003.548 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/2021/10/moneysmile-617x333.jpg" alt="" class="wp-image-226853"/><figcaption class="wp-element-caption">Money Smile vid en tidigare seger i Östersund med tränaren Per Lindetroth i vagnen. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">6Vilka är Östersundstravets bästa hästar? Nja, svaret kommer kanske inte vid dagens lunchtävlingar (första start 12.20), men där avgörs Östersundsmästaren för både varm- och kallblod med 50.000 kronor till vinnaren i varje. Loppen är enbart öppna för hästar med Östersund som hemmabana.</p>



<p>15 varmblod och 13 kallblod gör upp om titeln i flerklassloppen, där varmbloden är utspridda på fyra volter och kallbloden på fem.<br>Per Linderoth står bakom de mest meriterade av den varma rasen, där han han själv kör miljonären <strong>Money Smile</strong> (e. The Bank), medan Tomas Pettersson får chansen bakom dubbelmiljonären <strong>Donners Am</strong> (e. Infinitif).<br>På kallblodssidan är <strong>Bonaldo</strong> (e. Spikeld) mest meriterd och startar från 80 meters tillägg. Bonaldo var iblandad i olyckan i dubbelcupsfinalen på Bergsåkers V75-dag för 1,5 vecka sedan, men var själv oskyldig till att han kom loss och körande Daniel Wäjersten åkte ur vagnen.</p>



<p>Galoppens säsong i Sverige är inne på upploppet och blott tre tävlingsdagar återstår. Därmed blir det trav från svenska banor till lunch varje onsdag en tid framöver. </p>



<p><a href="https://sulkysport.se/wp-content/uploads/2024/11/241120.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till onsdagens tävlingar.</a></p>



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



<p class="has-drop-cap">7Vincennes har tävlingsfritt idag när franska löpningsserien Grand National du Trot har nått sista hållplatsen innan finalen på Vincennes den 1 december med 150.000 euro i total prissumma. Toulouse är skådeplatsen för årets 13:e försök i serien.</p>



<p>Bland deltagarna i dagens försök finns <strong>Igrec de Celland</strong> (e. Django Riff), som redan vunnit tre försök i serien. Christophe Jariel tränar och David Thomain sexåringen.<br>Ytterligare två försöksvinnare finns med i dagens startfält: <strong>Ibiki de Houelle</strong> (e. Love You), som vunnit två, och <strong>Iguski Sautonne</strong> (e. Village Mystic).</p>



<p>En svensk häst dyker upp i Toulouse. Maria Törnqvist-tränade <strong>Fighter Simoni</strong> (e. Orlando Vici) startar i Prix Zenitude (€30.000) över 2.950 meter och hästen får Alexandre Abrivard i vagnen. Fighter Simoni har tre segrar på åtta starter i Frankrike och möter exempelvis svenskfödda, exporterade duon <strong>Silver Bullit</strong> (e. Orlando Vici) och <strong>Staro Mojito</strong> (e. Make It Happen).</p>



<p><a href="https://sulkysport.se/trav-och-galopp/toulouse-2024-11-20/" target="_blank" rel="noreferrer noopener">Här är startlistorna till Toulouses tävlingar (första start 13.55).</a></p>



<p><strong>Startlista Grand National du Trot (€90.000)</strong><br><em>Häst (far) – Kusk</em><br><strong>2.950 meter:</strong></p>



<ol class="wp-block-list">
<li>Ginkgo Thelois (e. Quif de Villenneuve) – Manuel Criado</li>



<li>Happyjo de Ligny (e. Brillantissime) – Lana Henry</li>



<li>Fee Lucernaise (e. Quickly Paris) – Frédéric Clozier</li>



<li>Harry Carisaie (e. Viking de Val) – Eric Audebert</li>



<li>Goal Star (e. Look de Star) – Alexandre Abrivard</li>



<li>Iguski Sautonne (e. Village Mystic) – Matthieu Abrivard</li>



<li>Jakartas des Pres (e. Scipion du Goutiser) – Maxime Bezier</li>



<li>Gabriella Duem (e. Royal Dream) – Jerome Chavette</li>



<li>Invictus Madiba (e. Booster Winner) – Alexis Collette</li>



<li>Heraut d’Armes (e. Ready Cash) – Tristan Ouvrie</li>



<li>Have Seven (e. Prince d’Espace) – Nicolas Bazire <br><strong>2.975 meter:</strong></li>



<li>Igrec de Celland (e. Django Riff) – David Thomain</li>



<li>Ibiki de Houelle (e. Love You) – Eric Raffin</li>



<li>Fakir Merite (e. Uaukir) – Franck Marty</li>
</ol>

Fokustema
Sju nyheter vid sju
Läs senare
Kan komma in i celebert sällskap
Loppet som Victory Tilly, Hail Mary och Mustard vunnit. Svampenvinnare jagar revansch. Framgångsrikaste unga tränarna 2024. Fransk mångmiljonär död. Vem är bäst på Östersundstravet? Törnqvist jagar fransk seger.
Detta och med i onsdagens nyhetssvep.
Detta och med i onsdagens nyhetssvep.
