<p><span class="anfang">S</span>undbyholms dubbeltrav med V75 såväl lördag som söndag är här och det går inte klaga på den meny som serveras under lördagen,</p>
<p>Gulddivisionen (V75-7) blev ett riktigt topplopp för årstiden och känns därtill extra intressant då flera av de hästar som sannolikt blir lite mer betrodda har lottats till antingen lömska utgångslägen eller direkt problematiska i form av bakspår.</p>
<p>Vem som kommer bli störst favorit i omgången råder ingen som helst tvekan om. <strong>Vagabond Bi</strong> (V75-6) går fram som en ångvält och har återigen ett perfekt utgångsläge i Silverdivisionen. Tränare David Persson följde upp med en dubbel på Solvalla i fredags och visade att stallformen är på topp.<br />
Vid seger denna gång tar den italienskfödde valacken steget från silver- till gulddivisionen.</p>
<p>Omgångens stora varning finner vi i stayerloppet Salatrofén, men mer om det nedan&#8230;</p>
<p><a href="https://sulkysport.se/wp-content/uploads/2020/11/07v75.pdf" target="_blank" rel="noopener noreferrer">Här kan du ta del av startlistorna till lördagens tävlingar.</a></p>
<h2>Avd 1 – Klass I, 2.140 meter voltstart</h2>
<p>Lurig inledning där ingenting känns given vid en första anblick. <strong>Dwayne Zet</strong> kommer säkert få många anhängare från springspår. Han var inga mil från att kvala in till Derbyt och har nu fått ett lopp i kroppen, men övertygade kanske inte helt den dagen. <strong>Galileo Am</strong> var fyra i Åbys Stora Fyraåringspris i augusti. Därefter har han haft bakspår och det passar inte honom alls då hästen har problem i kurvorna och missgynnas av att gå ute i spåren. Den här uppgiften är passande rent motståndsmässigt. <strong>Dream Creation</strong> har inlett spännande i Svante Ericssons regi även om han felade från start senast. Dessförinnan har han varit riktigt bra. <strong>Global Viscount</strong> och <strong>Pine Muscle</strong> ska också duga i ett sådant här lopp liksom ultrastammade <strong>Upper Face</strong>.</p>
<h2>Avd 2 – Klass II, 2.640 meter autostart</h2>
<p>Lägsta klassen och lång distans&#8230; här är det inte säkert att alla kommer vara sådär hiskeligt flabbiga när det drar ihop sig till upplopp. <strong>Deal Done Zet</strong> kan säkert komma att bli favorit, men vi har inte bestämt oss ännu om detta är en vardags- eller lördagshäst. <strong>Global Above All</strong> felade direkt i klass II-debuten och får en ny chans. Den här distansen talar till hans fördel; det visade han med eftertryck vid segern på Solvalla gången innan. <strong>Amorcer Levallo</strong> har bärgat fyra raka segrar och visat att han duger i Mellansverige. <strong>Shut up and Dance</strong> gör sin femte raka klass II-start (!) och står verkligen på tur. Han är en av få distansgynnade hästen i loppet ihop med <strong>Zorro Kronos</strong>.</p>
<h2>Avd 3 – Stoeliten, 2.640 meter autostart</h2>
<p>Att inte Stoeliten samlat fullt fält går sannerligen att leva med när topparna är så pass vassa som de är i detta fall. <strong>Mellby Free</strong> radar toppinsatser och är loppets troliga ledarinna. Hon kommer att bli svårslagen. Sto SM-vinnaren <strong>Hevin Boko</strong> gillar den långa distansen, men det är hon inte ensam om i det här sammanhanget utan här är det fler som står sträckan. Den spontana känslan är att hon kommer få gå den långa vägen här. <strong>Racing Brodda</strong> gick mycket bättre i Sto SM än vad resultatet antyder. Hon är riktigt tuff och kanske den i fältet som gillar distansen allra mest. <strong>Activated</strong> fick<strong> Tessy d&#8217;Ete</strong> i släptåg senast, men lyckades ändå hålla undan med klar marginal. Det var en riktig plusinsats och nu kan det vara så att hon äntligen är tillbaka med besked.</p>
<h2>Avd 4 – Salatrofén, 3.140 meter voltstart</h2>
<p><strong>Pinto Bob</strong> tillhörde kulltoppen i fjol, men årets säsong har blott innehållit en start och då blev allt helt galet. Han är tillbaka i selen här efter ett bra kvalintryck och ska normalt sett vara bäst i sällskapet. I det här loppet finner vi omgångens kanske mest intressanta häst vid en första anblick i form av hemmahästen <strong>Hocus Pocus</strong>. Han har gjort två riktigt bra insatser i Sandra Loumalas regi och det vore mycket spännande att antingen se honom i tät eller i rygg på någon av <strong>Come Together</strong> eller <strong>Gazza B.R. Hurricane Silas</strong> trivs över distansen, men vinner sällan i lite bättre sällskap. <strong>Zizou</strong> har alltid en växel kvar även i de långa loppen om han får spara speeden. Katja Melkkos franska nyförvärv <strong>Carat du Goutier</strong> har främst tävlat på provinsbanor i födelselandet, men visat vettig högstanivå. Han tycks klara av tuffa lopp när han är i form och känns inte helt golvad.</p>
<h2>Avd 5 – Bronsdivisionen, 1.640 meter autostart</h2>
<p><strong>Moses</strong> övertygade vid segrarna, men felade därefter från start i klass I-finalen på Solvalla. Normalt sett är detta en väldigt passande uppgift, men innerspår bakom bilen är alltid lite lurigt utifrån såväl risken att bli snuvad på tät som risken att hästen kan hetsa upp sig och galoppera när konkurrenterna kommer på honom utifrån. <strong>In Royalty Boko</strong> har fått ett nyttigt lopp i kroppen efter paus. Den högstanivå som hon visat tidigare under året har varit riktigt vass för klassen och hon ska behandlas med största respekt här. Loppets bredd övertygar inte och här känns hästar som <strong>Manuzio Hanover</strong>, <strong>Neelix</strong> och <strong>Fonda Boko</strong> småaktuella trots missgynnsamma utgångsläge.</p>
<h2>Avd 6 – Silverdivisionen, 2.140 meter autostart</h2>
<p>Här kommer sannolikt omgångens största favorit i <strong>Vagabond Bi</strong> och det ska han också vara utifrån hur hästen sett ut nu en längre period. Senast i Gävle visade han prov på en startsnabbhet som var okänd för den breda massan och trots att han drog iväg väl mycket kontra vad kusken önskade så såg Vagabond Bi ut att vara närmast okörd på 1.11,7a/2.140 meter. Vid en första anblick är det svårt att hitta varför han inte ska vinna igen. <strong>Coogan</strong> satt fast med rubbet sparat i en trött rygg i just Vagabond Bi-loppet senast i Gävle. <strong>Jacques Noir</strong> var bra vid segern, men inte alls sig lik senast. <strong>Religious</strong> kommer från några sämre resultat, men brukar alltid gå bra på svensk mark.</p>
<h2>Avd 7 – Gulddivisionen, 2.140 meter autostart</h2>
<p>Senhöstens guldlopp fortsätter hålla hög klass, årstiden tills trots. <strong>Zarenne Fas</strong> trodde vi mycket på i Örebro och fick också full utdelning på. Han kan öppna bra bakom bilen, men frågan är om det verkligen räcker för att hålla upp innerspåret. <strong>Hachiko de Veluwe</strong> höll starkt från dödens senast i Gävle bakom From the Mine. Risken är påtaglig att han får gå den vägen på nytt. <strong>Milligan&#8217;s School</strong> och <strong>Heavy Sound</strong> har båda lottats till bakspår återigen och samma sak gäller <strong>Forfantone Am</strong>. De kan samtliga vinna med klaff, men är verkligen utelämnade. <strong>Elian Web</strong> såg fin ut då han vann på banrekord i Gävle, men från spår tolv bör han få det väldigt svårt här.</p>
