
<p class="has-drop-cap">1Fyra Kriteriefinalister och en Oaksfinalist dyker upp på Solvalla (start 18.15), där det bjuds en fin onsdagsgiv med revanschlopp för kullens största treåringslopp med 200.000 kronor i förstapris i båda. Dessutom spetsas tävlingarna med finaler i Solvallaseriens tre klasser med 150.000 kronor till vinnaren i varje.</p>



<p>Bland treåringarna är det stora namnet en häst som missade Kriteriet, Roger Walmann-tränade <strong>S.G.Dracarys </strong>(e. Bold Eagle) tillhör absoluta kulltoppen efter andraplatsen i långa E3 och seger i Kriteriet consolation. De fyra Kriteriefinalisterna bland motståndarna är fyran<strong> Herakles Zet</strong> (e. Propulsion), femman<strong> Fusion Eagra</strong> (e. Django Riff), <strong>Pantocrator</strong> (e. Quarcio du Chene) och <strong>Kuiper</strong> (e. Face Time Bourbon).</p>



<p>Timo Nurmos-tränade <strong>Granger</strong> (e. Trixton) var hårt betrodd som andrahandsfavorit i Oaks, där hon kördes i ledningen av Mats E Djuse. Krafterna räckte dock inte hela vägen och hon föll tillbaka till femteplatsen. Nu ställs hon mot två starka ston från storebror Mattias stall, nämligen <strong>Frustration</strong> (e. Fourth Dimension) och <strong>Larah Westwood</strong> (e. The Bank).</p>



<p>Finalerna i Solvallaserien då? Björn Goop-tränade <strong>Jascal</strong> (e. Trixton) vann final i lägsta klassen i början av oktober och nu kan han fylla på med en triumf i mellanklassen.</p>



<p>Oaksrevanschen och de tre finalerna utgör Solvallas del av V86-kupongen som delas med Bjerke.</p>



<p><em>Vill du spela V86 tillsammans med Sulkysport kan du välja mellan följande alternativ:</em></p>



<p><a href="https://www.atg.se/andelskungen/spel/251721_V86_2023-11-22_40_1" class="">Sulkysport Lilla V86 – 15 andelar á 95 kr/styck</a></p>



<p><a href="https://www.atg.se/andelskungen/spel/206235_V86_2023-11-22_40_1" class="">Sulkysport Stora V86 – 15 andelar á 250 kr/styck</a></p>



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



<p class="has-drop-cap">2Bjerke (första start kl. 18.27) är kvällens saxbana och det osar onekligen vardag över tävlingarna.</p>



<p>De riktiga profilhästarna lyser med sin frånvaro även om det finns sex bekanta namn i tävlingsdagens avslutande lopp tillika V86-spelets sjunde avdelning.</p>



<p>De är blott halva dussinet till antalet, men Olav Mikkelborgs The Baron (e. Dream Vacation), Hilde Mari Stumbergs Jackson Avery (e. Credit Winner) och Frode Hamres Skate Trix (e. Trixton) är samtliga hästar som tävlat flitigt i onsdags- och lördagslopp.</p>



<p>Tävlingsdagens mest intressanta lopp kan dock vara en uppgörelse stängd vid 95.000 norska kronor.<br>Thor Borgs svenskfödda Maharajah-dotter <strong>Maharasha</strong> är halvsyster till fjolårets norska Stoderbytrea tillika tvåfaldiga V75-vinnare <strong>Readly&#8217;s Dream</strong> (e. Readly Express) och hon möter en inhemsk Maharajah-treåring vid namn King Okay.<br>Den sistnämndes mor Reallyokay är helsyster till den forne, norske Derbytvåan <strong>Cash Okay</strong>, 1.11,0ak/3.158.097 nok vilken numera står uppstallad som avelshingst hos Västerbo Stuteri.</p>



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



<p class="has-drop-cap">3Idag kliver travet in som värd för lunchtävlingar även på onsdagar när galoppen går ner i varv under vintern. Bergsåker (start 12.20) är först ut denna vinter och två hästar som fått varsitt lopp i kroppen efter långa tävlingsuppehåll dyker upp.</p>



<p>Åbytränaren Peter Grundmanns kallblod <strong>Basisten </strong>(e. Horgen Tore) vann fem av sex starter förra året, men hade sedan borta i nästan 14 månader då han skulle göra comeback i Årjäng. Då var dock olyckan framme. Basisten slog och träffade Peter så illa att han drabbades av en fraktur, som hållit honom borta från tävlingssulkyn ända till i morgon då han kör ett kvallopp på Åby.</p>



<p>Basisten däremot fick flytta till Hagmyrentränaren Jan Ove Olsen, där han debuterade med en andraplats i mitten av oktober. Då handlade det om lång distans – i dagens lunchstart är distansen ett varv kortare.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2019/10/globaladventure-617x309.jpg" alt="" class="wp-image-54548"/><figcaption class="wp-element-caption">Global Adventure. Foto Mia Törnberg/Sulkysport</figcaption></figure>



<p>Svante Båths unghäststjärna <strong>Global Adventure</strong> (e. S.J.’s Caviar), 1.10,4ak/5.369.638 kr, vann Svampen som tvååring, slutade tvåa i korta E3 och Breeders Crown som treåring och var fyra i Derbyt och Breeders Crown året efter. Som äldre finns bland annat gulddivisionssegern i Gävle Stora Pris på meritlistan. Efter sju månaders uppehåll gjorde hästen comeback med seger i ett breddlopp för tre veckor sedan och idag väntar alltså lunchlopp och 40 meters tillägg över medeldistans.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2023/11/231122.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">4Den 14:e och sista etappen av Grand National du Trot (€90.000) avgörs idag i franska Mauqenchy (första start kl. 13.55) innan finalen med 150.000 euro i samlad prissumma stundar på Vincennes söndag den 3 december.</p>



<p>I dagens startfält kryllar det av toppnamn såsom <strong>Horace du Goutier</strong> (e. Ready Cash), <strong>Gaspar de Brion</strong> (e. Singalo),<strong> Emeraude de Bais </strong>(e. Repeat Love) och <strong>Delia du Pommereux</strong> (e. Niky) vilka samtliga ska försöka jobba sig ikapp från tillägg på en så pass bra häst som <strong>Instrumentaliste</strong> (e. Ready Cash).</p>



<p>Tre svensktränade hästar tävlar likaså i Maquenchy. I Prix Andre Perdrix (€35.000) bidrar Jarmo Niskanen med <strong>Jockstrap</strong> (e. Prince Gede) och i Prix Jaguar (€40.000) syns såväl Björn Goops<strong> Icarus Bourbon</strong> (e. Prodigious) som Marie Norbergs <strong>Istania de Viette</strong> (e. Carat Williams).</p>



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



<p class="has-drop-cap">5Stall Segerhuva har plockat hem svenskfödda <strong>Flying Drumsticks </strong>(e. Muscle Hill) 1.09,7ak/580.825 kr från USA och satt stoet i träning hos Conrad Lugauer.</p>



<figure class="wp-block-image alignright size-full"><img src="https://sulkysport.se/wp-content/uploads/2023/10/lugauerconrad231004adamstromstalltz-scaled.jpg" alt="" class="wp-image-505567"/><figcaption class="wp-element-caption">Conrad Lugauer. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p>Den treåriga damen står med sex segrar på tio starter och avslutade säsongen med en tredjeplats i Bluegrass Series ($78.000) i Lexington på 1.09,7 trots galopp. Det efter att avslutat 1.04,1 sista quartern! Åke Svanstedt tränade stoet i USA.</p>



<p>Det fartfyllda stoet är en dotter till <strong>Timbal</strong> (e. From Above) 1.12,4am/2.676.479 kr som bland sina 20 segrar på 32 starter noterades för fullträff i E3-final för ston i Robert Berghs regi.</p>



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



<p class="has-drop-cap">6Söndagens publiksiffra på Vincennes i samband med att Prix de Bretagne avgjordes var ett stort glädjeämne för det franska travförbundet.</p>



<p>Det är danska Travservice.dk som uppmärksammar att det franska travförbundets satsning på Dimanche Plaisirs – Söndagsnöjen rakt översatt – med mängder av kringaktiviteter för såväl barn som vuxna lockade en noterbar besöksskara á 8.300 personer kontra drygt 4.000 föregående år.</p>



<p>Undertecknad utgår från att representanter från ST kommer besöka fransmännens Dimanche Plaisirs och se om de kan dra några lärdomar att använda till STL:s Sommartrav som ska äga rum även år 2024.</p>



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



<p class="has-drop-cap">7Bollnäsproffset Patricia Gordin meddelar på Facebook att hon lämnar in sina trav och galopplicenser vid årsskiftet.</p>



<p>51-åringen är mest känd som kvinnan bakom profilhästen <strong>Sean Banan</strong> (e. Jaded) 1.13,9ak/555.060 kr som vann åtta av karriärens 98 starter och varav två fullträffar noterades redan under tvååringsäsongen.</p>

Fokustema
Morgonsvepet
Läs senare
Revanscher och finaler
Om kvällens penningstinna tävlingar på Solvalla, högintressant nyförvärv hos Conrad Lugauer och markant publikökning på Vincennes går bland annat att läsa i dagens morgonsvep.
