
<p class="has-drop-cap">1Examensdags för svenskfödda tvååringar och elva ungdomar – Paul Hagoort har tvingats stryka <strong>O&#8217;Hara Boko</strong> (e. Robert Bi) för halsinfektion – finns bakom bilvingen för att tävla om förstapriset 1,6 miljoner kronor i Svensk Uppfödningslöpning på Jägersro.</p>



<p>Svenska rekorden för tvååringar kan vara bra att veta inför dagens final. Snabbaste svenskfödde hingst/valack är <strong>Smokin Joe</strong> (e. Lavec Kronos-Knowledge Face) med tiden 1.12,6a/1.640 meter, satt den 26 september 2017 på Jägersro. <strong>Denim Boko</strong> (e. Chocolatier-Radiant Lindy) toppar på stosidan med 1.12,9, vilken hon noterade som etta i Svensk Uppfödningslöpning 2012.<br>Från 1.600 meter till 2.140 meter har distansen varierat i Svensk Uppfödningslöpning sedan premiäråret 1926. <strong>Fascination</strong> (e. Super Arnie) vann senaste – sista? – året över medeldistans 2011 på snabbaste tiden över distansen, 1.15,3a/2.140 meter. Snabbaste sprintern är <strong>Coin Perdu</strong> (e. S.J.’s Caviar) 2016.</p>



<p>Per Nordström har kvalat in två hästar i finalen och <strong>Monster Wine</strong> (e. Googoo Gaagaa) var snabbast av de fyra kvalvinnarna när han travade 1.13,3a/1.640 meter vid segern i försöket. Övriga vinnare var Dannu Brouwers <strong>Oriana Boko</strong> (e. Father Patrick) 1.13,7, Diederik Meilinks <strong>Romulus Tooma </strong>(e. S.J.’s Caviar) 1.13,8 och Fredrik Wallins <strong>Matchmadeinheaven</strong> (e. S.J.’s Caviar).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/11/fiftyfourmalgang-617x411.jpg" alt="" class="wp-image-382295"/><figcaption class="wp-element-caption">Ken Ecce och Fiftyfour vid segern i Svensk Uppfödningslöpning ifjol. Foto MiRoMedia</figcaption></figure>



<p>Förra årets vinnare <strong>Fiftyfour</strong> (e. Fourth Dimension), tränad av Tomas Malmqvist, dyker upp på Jägersro även idag. Löpningsserien Breeders Course har två superbonuslopp för treåringar, ett för vardera kön, med hela 400.000 kronor i förstapris i varje! Det har fått Alessandro Gocciadoro att lasta hästbussen i Italien med <strong>Everything Bi</strong> (e. Varenne) och <strong>Esmeralda Bez</strong> (e. Maharajah). </p>



<p><a href="https://sulkysport.se/bara-en-chans-kvar/" target="_blank" rel="noreferrer noopener">––> Hästarna, historierna, uppfödarna, ägarna, tränarna, kuskarna och skötarna i sammanställningen ”Det snackas om Svensk Uppfödningslöpning”.</a></p>



<h2 class="wp-block-heading">Snabbaste vinnarna av Svensk Uppfödningslöpning</h2>



<p><em>År, häst (far) – Kusk tränare) – Segertid</em></p>



<ul class="wp-block-list">
<li>2016 Coin Perdu (e. S.J.’s Caviar) – Erik Adielsson (Svante Båth) – 1.12,7a</li>



<li>2012 Denim Boko (e. Chocolatier) – Per Nordström – 1.12,9a</li>



<li>2017 Global Welcome (e. S.J.’s Caviar) – Erik Adielsson (Svante Båth) – 1.13,1a</li>



<li>2019 Revelation (e. Ready Express) – Per Nordström – 1.13,4a</li>



<li>2022 Fiftyfour (e. Fourth Dimension) – Ken Ecce (Tomas Malmqvist) – 1.13,4a</li>



<li>2013 Onceforall Face (e. Viking Kronos) – Lutfi Kolgjini – 1.13,7a</li>



<li>2018* Belker (e. Scarlet Knight) – Torbjörn Jansson (Sten O Jansson) – 1.13,7a</li>



<li>2018* Bythebook (e. Googoo Gaagaa) – Örjan Kihlström (Svante Båth) – 1.13,7a</li>
</ul>



<p><em>Samtliga ovanstående tider är noterade över 1.640 meter med autostart.</em><br>* Belker och Bythebook löpte dött lopp om segern.</p>



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



<p class="has-drop-cap">2<strong>Denim Boko</strong> (e Chocolatier) och <strong>Tetrick Wania</strong> (e. Muscle Hill) kan så sällskap. Somvinnare av dubbeln Svampen och Svensk Uppfödningslöpning alltså. Per Nordström var mannen bakom Denim Boko som vann stoavdelningen av Svampen (loppet var delat mellan könen då) och Uppfödningsloppet 2012. För två år sedan var det Riina Rekiläs Tetrick Wanias tur att lyckas med uppgiften.</p>



<p>I eftermiddag kan dubbelvinnande duon få sällskap. För fem veckor sedan vann nämligen Fredrik Wallin-tränade <strong>Matchmadinheaven</strong> (e. S.J.’s Caviar) Örebros stora tvååringslopp och efter försöksseger är hon favorit i Svensk Uppfödningslöpning.<br>– Jag visste att det skulle vara en tidig häst, men när hon började tävla var det tvärtemot det hon visat i träning. Hon sprang och bromsade och jag var väldigt besviken på henne i början, men sedan vi satte på helstängt huvudlag har hon fokuserat, sade Fredrik Wallin till V65 Direkt.</p>



<p>Matchmadeinheaven är mest rutinerad i tvååringsfältet med sju starter innanför västen, men första segern dröjde till sjätte starten, just Svampen. Av bara farten segrade hon också i kvalet.<br>– Allt har flutit på bra efteråt. Vädret har slagit om, men vi har kunnat jobba som vi velat och hon var fin i ett banjobb i onsdags, sade Fredrik.</p>



<p>Men vem vinner då tvååringsklassikern? Här är Sulkysports experts drag:<br><em>”Vi tycker att årets största tvååringslopp är en vidöppen historia och chanstippar <strong>Valnes Phenix</strong> (V75-4), men tar fram den bredaste penseln och helgarderar loppet.”</em></p>



<p><a href="https://sulkysport.se/spelstugan/v75-tips-25-november/" target="_blank" rel="noreferrer noopener">Här är Sulkysports stora tipsgenomgång med analyser, spetsbud, spikar, drag och ranking av alla hästar på V75.</a></p>



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



<p class="has-drop-cap">3Tvååriga hästar i Svensk Uppfödningslöpning inom V75 – och snabbloppshästarna med tidigare Jägersrotränade <strong>Kentucky River</strong> (e. Father Patrick) i spetsen ska hylla forne Jägersrotränaren Lars Gustafssons topphäst <strong>Meadow Prophet</strong> (e. Speedy Somolli).<br>Meadow Prophet kom till Jägersrotränaren som treåring och utvecklades till en topphäst. Han vann exempelvis treåringsstjärnan i Gävle, fyraåringseliten på Solvalla och slutade tvåa i guldfinal samma år. Som femåring klev han in i eliten på allvar och var tvåa i Elitloppet bakom kanadensiske Billyjojimbob 1992 efter att på våren vunnit Silverhästen på Solvalla.<br>Året efter slutade Meadow Prophet fyra i Elitloppet innan säsongen avslutades med seger i Müllers på hemmaplan, Gran Premio delle Nazione i Milano och Gran Premio Gaetano Turilli i Rom.</p>



<p>Sedan kom tragiken.</p>



<p>På väg norrut från Rom fattade hästtransporten med Meadow Prophet, First Sid (Björn Linder) och Park Avenue Kathy (Göran E Johansson) eld och den svensktränade trion dog. Tre framgångsrika travliv dog och idag minns Jägersro en av dem med Meadow Prophets Minne. Totalt gjorde Meadow Prophet 61 starter (25–14–11) och tjänade cirka sju miljoner kronor.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/07/kentuckyriverpnm220720adamstromstalltz-617x384.jpg" alt="" class="wp-image-330643"/><figcaption class="wp-element-caption">Kentucky River vid fjolårets seger i Eskilstunas Fyraåringstest i regi Per Nordström. Foto Adam Ström/stalltz.se</figcaption></figure>



<p>Sulkysports vinnare i eftermiddagens gulddivision är Daniel Redéns nyförvärv Kentucky River, som gör andra starten för Redén. Regidebuten började i mål med hejdlös galopp.<br>– Jag hade High On Pepper på insidan och ville komma förbi den, men Kentucky slog ihop när han skulle accelerera. Han kändes väldigt mjuk och fin, jag körde bara fort i 500 meter för att känna att han var okej och han kändes fin. Nu när han har bakspår är jag inte orolig för att han ska galopperade, men han har inte fått ett riktigt lopp sedan i augusti så det är ett frågetecken. Hästen är allround och tål att göra jobb själv. Vi vill se att han gör en bra insats för meningen är att han ska åka till Frankrike, sade Örjan Kihlström till V65 Direkt.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2023/11/25v75.pdf">Här kan du ta del av startlistor till tävlingarna på Jägersro.</a></p>



<p><em>Vill du spela V75 tillsammans med Sulkysport finns följande alternativ:</em></p>



<p><a href="https://www.atg.se/andelskungen/spel/206687_V75_2023-11-25_7_5">Sulkysport Lilla V75 – 15 andelar á 75 kr/styck</a></p>



<p><a href="https://www.atg.se/andelskungen/spel/206688_V75_2023-11-25_7_5">Sulkysport V75 – 15 andelar á 150 kr/styck</a></p>



<p><a href="https://www.atg.se/andelskungen/spel/206689_V75_2023-11-25_7_5">Sulkysport Stora V75 – 15 andelar á 250 kr/styck</a></p>



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



<p class="has-drop-cap">4Tre svenskfödda hästar och en svensktränad, men franskfödd, springare kliver idag upp i ringen mot Frankrikes bästa fyraåring <strong>Joshua Tree</strong> (e. Bold Eagle) när Prix de Chenonceaux (€80.000) avgörs på Vincennes (första start kl 13.58).<br>Robert Bergh är själv på plats och kör sin <strong>Kagan</strong> (e. Scarlet Knight) i detta kombinerade fyra- och femåringslopp, Gabriele Gelormini ges chansen bakom Fredrik Wallins Derbystovinnare <strong>Global Dancer</strong> (e. Carat Williams), Nicolas Bazire kör den på skor tävlande <strong>Cool Kronos</strong> (e. Readly Express) och så rattar Alexis Collette Tomas Malmqvists<strong> Isla Jet</strong> (e. Bold Eagle).<br>Förutsättningarna stavas 2.700 meter voltstart och det är 36.000 euro på spel till vinnaren.</p>



<p>Tomas Malmqvist tävlar även med <strong>Lash Perrine</strong> (e. Django Riff) i det Grupp III-klassade tvååringsloppet Prix Timoko (€60.000) samt <strong>Killer Queen</strong> (e. Face Time Bourbon) i Prix d’Angles (€62.000) och därtill syns Rikard Björlings <strong>Istra</strong> (e. Ulysse) tävla i Prix de Manciet (€41.000).</p>



<p><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2023-11-25/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna på Vincennes.</a></p>



<p>Under seneftermiddagen tävlas det därtill i Reims (första stat kl. 16.42) och där har Jarmo Niskanen och Ron Kuiper två bidrag vardera. Niskanen treåring <strong>King Elvis</strong> (e. Bold Eagle) jagar karriärens andra seger i Prix Film lomme Qui Murmurait A L.O.D.C. (€18.000) och den tvåårige debutanten <strong>Lord</strong> (e. Earl Simon) inleder sin karriär i Prix Jean Pierre Vatageot (€19.000).<br>Kuipers starthästar är i sin tur <strong>Hit Money</strong> (e. Cristal Money) i Grand Prix Zeturf (€24.000) och <strong>Kolyta du Chene</strong> (e. Diablo du Noyer) i Prix du Film La Chefauchee Sauvage (€18.000).</p>



<p><strong>Så gick det för gårdagens svenskhopp på Vincennes:</strong><br><em>Hästnamn (far) – Tränare – Placering – Prispengar</em></p>



<ul class="wp-block-list">
<li><strong>Keynote</strong> (e. Face Time Bourbon) – Tomas Malmqvist – sexa – 1.240 euro</li>
</ul>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/08/tacticalapproachszm230805adamstromstalltz-1-617x418.jpg" alt="" class="wp-image-479584"/><figcaption class="wp-element-caption">Tactical Approach vinner Hambletonian Stakes för Scott Zeron. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap">5Nancy Takters Hambletonian-vinnare <strong>Tactical Approach</strong> (e. Tactical Landing) gör sin karriärs sista start i Fanduel Championship Open Trot ($350.000) för äldre hästar och treåringen ställs mot tre travare från Åke Svanstedts stall; <strong>Alrajah One </strong>(e. Maharajah), <strong>Southwind Tyrion</strong> (e. Muscle Hill) och <strong>Rattle My Cage</strong> (e. Love You).</p>



<p>Detta sker på Meadowlands i natt där det står ett koppel storlopp på menyn. Det handlar om finalerna i tvååringsloppen Valley Victory ($423.000) och Goldsmith Maid ($428.000), samt Fanduel Championship ($175.000) för ston.<br>I det sistnämnda loppet kan Åke Svanstedt-tränade <strong>Jiggy Jog</strong> (e. Walner) bli dollarmiljonärska för andra året i rad som hon grejar en plats bland de två bästa i loppet. Tio starter i år (7-3-0) i år har givit 950.986 dollar för det svenskfödda stoet.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2023/11/mxx1125p.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Meadowlands stortävlingar.</a></p>



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



<p class="has-drop-cap">6Lassagården har varit en maktfaktor i svensk travsport och gårdens historia med hästar började redan 1916, då med uppfödning och hingsthållning. Lassagårdens stora namn var Ingmar Andersson och det var hans farfar som drog igång med hästarna för 107 år sedan.<br>Ingmar Andersson gjorde stora avtryck inom travsporten och var en stark röst fram till sin död 2013. På Lassagården stallades championhingstar som <strong>Quick Pay</strong> (tre gånger) och <strong>Count’s Pride</strong> (två gånger) upp och på Lassagården har bland annat tre Kriterievinnare fötts upp.<br>Sedan 1999 körs Lassagårdspokalen för treåriga hästar i Axevallaträning och ikväll är det dags för årets upplaga, där Ingmar Andersson har skänkt en silverpokal som ska erövras tre gånger av samma ägare för att bli ständig egendom.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/10/lokesancydiamond-617x333.jpg" alt="" class="wp-image-510741"/><figcaption class="wp-element-caption">Loke Sancy Diamond har bytt tränare – från Roger Walmann till Ulf Stenströmer. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Årets vinnare av Guldstoet, <strong>Loke Sancy Diamond</strong> (e. Raja Mirchi), debuterar i Ulf Stenströmers regi efter att ha lämnat Roger Walmann i mitten av oktober.<br>– Det blir bara detta lopp nu under hösten och sedan börjar vi uppladdningen mot nästa säsong och förhoppningsvis de stora fyraåringsloppen. Hästen har blivit åtgärdad två gånger och tränar nu jättefint, hon har känts stark och fin i sanden och kryddade det med ett banjobb efter 1.17,5/1.600 meter helt nyligen, säger Stenströmer i Axevallas banprogram.</p>



<p>Förutom Lassagårdspokalen avgörs Hästägarepokalen med 50.000 kronor till vinnaren.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2023/11/231125.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till lördagens tävlingar.</a></p>



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



<p class="has-drop-cap">7Ett digert utbud med framför allt starthästar väntar på Traveras lördagsauktion. 38 hästar och en betäckning 2024 i Greenshoe ligger ute till försäljning.<br>Bland 24 starthästar finns fyraåriga <strong>Jelly Bean Mearas</strong> (e. Cantab Hall), som vann en avdelning i Margaretas Tidiga Unghästserie i somras.</p>



<p>Två ettåringar (e. Explosive Matter och Googoo Gaagaa), tvååriga Propulsion-dottern <strong>The Rose</strong>, som travat 1.15,1ak på Jägersro, och elva fölston finns också i den digitala katalogen.</p>



<p><a href="https://www.travera.nu/kopa-hast/" target="_blank" rel="noreferrer noopener">Här går det att se hästarna som bjuds ut och följa budgivningen under kvällen.</a></p>

Fokustema
Morgonsvepet
Läs senare
På jakt efter sista klassikern
Matchmadeinheaven kan bli trea i historien. Rekorden att slå i tvååringsklassikern. 31 är efter tragiska hästbussbranden. Vassa svenskar på Vincennes. Guldstovinnare debuterar i ny regi.
Detta och mer i lördagens ”Sju nyheter vid sju”.
Detta och mer i lördagens ”Sju nyheter vid sju”.
